feat(service): introduce hyper-specific Service

This introduces the `hyper::service` module, which replaces
`tokio-service`.

Since the trait is specific to hyper, its associated
types have been adjusted. It didn't make sense to need to define
`Service<Request=http::Request>`, since we already know the context is
HTTP. Instead, the request and response bodies are associated types now,
and slightly stricter bounds have been placed on `Error`.

The helpers `service_fn` and `service_fn_ok` should be sufficient for
now to ease creating `Service`s.

The `NewService` trait now allows service creation to also be
asynchronous.

These traits are similar to `tower` in nature, and possibly will be
replaced completely by it in the future. For now, hyper defining its own
allows the traits to have better context, and prevents breaking changes
in `tower` from affecting hyper.

Closes #1461

BREAKING CHANGE: The `Service` trait has changed: it has some changed
  associated types, and `call` is now bound to `&mut self`.

  The `NewService` trait has changed: it has some changed associated
  types, and `new_service` now returns a `Future`.

  `Client` no longer implements `Service` for now.

  `hyper::server::conn::Serve` now returns `Connecting` instead of
  `Connection`s, since `new_service` can now return a `Future`. The
  `Connecting` is a future wrapping the new service future, returning
  a `Connection` afterwards. In many cases, `Future::flatten` can be
  used.

src/service/new_service.rs

@@ -0,0 +1,55 @@
+use std::error::Error as StdError;
+
+use futures::{Future, IntoFuture};
+
+use body::Payload;
+use super::Service;
+
+/// An asynchronous constructor of `Service`s.
+pub trait NewService {
+    /// The `Payload` body of the `http::Request`.
+    type ReqBody: Payload;
+
+    /// The `Payload` body of the `http::Response`.
+    type ResBody: Payload;
+
+    /// The error type that can be returned by `Service`s.
+    type Error: Into<Box<StdError + Send + Sync>>;
+
+    /// The resolved `Service` from `new_service()`.
+    type Service: Service<
+        ReqBody=Self::ReqBody,
+        ResBody=Self::ResBody,
+        Error=Self::Error,
+    >;
+
+    /// The future returned from `new_service` of a `Service`.
+    type Future: Future<Item=Self::Service, Error=Self::InitError>;
+
+    /// The error type that can be returned when creating a new `Service.
+    type InitError: Into<Box<StdError + Send + Sync>>;
+
+    /// Create a new `Service`.
+    fn new_service(&self) -> Self::Future;
+}
+
+impl<F, R, S> NewService for F
+where
+    F: Fn() -> R,
+    R: IntoFuture<Item=S>,
+    R::Error: Into<Box<StdError + Send + Sync>>,
+    S: Service,
+{
+    type ReqBody = S::ReqBody;
+    type ResBody = S::ResBody;
+    type Error = S::Error;
+    type Service = S;
+    type Future = R::Future;
+    type InitError = R::Error;
+
+
+    fn new_service(&self) -> Self::Future {
+        (*self)().into_future()
+    }
+}
+