fs: add support for non-threadpool executors (#1495)

Provides a thread pool dedicated to running blocking operations (#588)
and update `tokio-fs` to use this pool.

In an effort to make incremental progress, this is an initial step
towards a final solution. First, it provides a very basic pool
implementation with the intend that the pool will be
replaced before the final release. Second, it updates `tokio-fs` to
always use this blocking pool instead of conditionally using
`threadpool::blocking`. Issue #588 contains additional discussion around
potential improvements to the "blocking for all" strategy.

The implementation provided here builds on work started in #954 and
continued in #1045. The general idea is th same as #1045, but the PR
improves on some of the details:

* The number of explicit operations tracked by `File` is reduced only to
  the ones that could interact. All other ops are spawned on the
  blocking pool without being tracked by the `File` instance.

* The `seek` implementation is not backed by a trait and `poll_seek`
  function. This avoids the question of how to model non-blocking seeks
  on top of a blocking file. In this patch, `seek` is represented as an
  `async fn`. If the associated future is dropped before the caller
  observes the return value, we make no effort to define the state in
  which the file ends up.

tokio-fs/src/stdin.rs

@@ -1,8 +1,8 @@
-use crate::blocking_io;
+use crate::blocking::Blocking;
 
 use tokio_io::AsyncRead;
 
-use std::io::{self, Read};
+use std::io;
 use std::pin::Pin;
 use std::task::Context;
 use std::task::Poll;
@@ -24,7 +24,7 @@ use std::task::Poll;
 /// [`AsyncRead`]: trait.AsyncRead.html
 #[derive(Debug)]
 pub struct Stdin {
-    std: std::io::Stdin,
+    std: Blocking<std::io::Stdin>,
 }
 
 /// Constructs a new handle to the standard input of the current process.
@@ -33,15 +33,17 @@ pub struct Stdin {
 /// Tokio runtime.
 pub fn stdin() -> Stdin {
     let std = io::stdin();
-    Stdin { std }
+    Stdin {
+        std: Blocking::new(std),
+    }
 }
 
 impl AsyncRead for Stdin {
     fn poll_read(
         mut self: Pin<&mut Self>,
-        _cx: &mut Context<'_>,
+        cx: &mut Context<'_>,
         buf: &mut [u8],
     ) -> Poll<io::Result<usize>> {
-        blocking_io(|| (&mut self.std).read(buf))
+        Pin::new(&mut self.std).poll_read(cx, buf)
     }
 }