feat(lib): redesign API to use Futures and Tokio

There are many changes involved with this, but let's just talk about
user-facing changes.

- Creating a `Client` and `Server` now needs a Tokio `Core` event loop
to attach to.
- `Request` and `Response` both no longer implement the
`std::io::{Read,Write}` traits, but instead represent their bodies as a
`futures::Stream` of items, where each item is a `Chunk`.
- The `Client.request` method now takes a `Request`, instead of being
used as a builder, and returns a `Future` that resolves to `Response`.
- The `Handler` trait for servers is no more, and instead the Tokio
`Service` trait is used. This allows interoperability with generic
middleware.

BREAKING CHANGE: A big sweeping set of breaking changes.

benches/end_to_end.rs

@@ -0,0 +1,61 @@
+#![feature(test)]
+
+extern crate futures;
+extern crate hyper;
+extern crate tokio_core;
+
+extern crate test;
+
+use futures::{Future, Stream};
+use tokio_core::reactor::Core;
+
+use hyper::header::{ContentLength, ContentType};
+use hyper::server::{Service, Request, Response};
+
+
+#[bench]
+fn one_request_at_a_time(b: &mut test::Bencher) {
+    extern crate pretty_env_logger;
+    let _ = pretty_env_logger::init();
+    let mut core = Core::new().unwrap();
+    let handle = core.handle();
+
+    let addr = hyper::Server::http(&"127.0.0.1:0".parse().unwrap(), &handle).unwrap()
+        .handle(|| Ok(Hello), &handle).unwrap();
+
+    let mut client = hyper::Client::new(&handle);
+
+    let url: hyper::Url = format!("http://{}/get", addr).parse().unwrap();
+
+    b.bytes = 160;
+    b.iter(move || {
+        let work = client.get(url.clone()).and_then(|res| {
+            res.body().for_each(|_chunk| {
+                Ok(())
+            })
+        });
+
+        core.run(work).unwrap();
+    });
+}
+
+static PHRASE: &'static [u8] = b"Hello, World!";
+
+#[derive(Clone, Copy)]
+struct Hello;
+
+impl Service for Hello {
+    type Request = Request;
+    type Response = Response;
+    type Error = hyper::Error;
+    type Future = ::futures::Finished<Response, hyper::Error>;
+    fn call(&mut self, _req: Request) -> Self::Future {
+        ::futures::finished(
+            Response::new()
+                .with_header(ContentLength(PHRASE.len() as u64))
+                .with_header(ContentType::plaintext())
+                .with_body(PHRASE)
+        )
+    }
+
+}