feat(error): revamp hyper::Error type

**The `Error` is now an opaque struct**, which allows for more variants to
be added freely, and the internal representation to change without being
breaking changes.

For inspecting an `Error`, there are several `is_*` methods to check for
certain classes of errors, such as `Error::is_parse()`. The `cause` can
also be inspected, like before. This likely seems like a downgrade, but
more inspection can be added as needed!

The `Error` now knows about more states, which gives much more context
around when a certain error occurs. This is also expressed in the
description and `fmt` messages.

**Most places where a user would provide an error to hyper can now pass
any error type** (`E: Into<Box<std::error::Error>>`). This error is passed
back in relevant places, and can be useful for logging. This should make
it much clearer about what error a user should provide to hyper: any it
feels is relevant!

Closes #1128
Closes #1130
Closes #1431
Closes #1338

BREAKING CHANGE: `Error` is no longer an enum to pattern match over, or
  to construct. Code will need to be updated accordingly.

  For body streams or `Service`s, inference might be unable to determine
  what error type you mean to return. Starting in Rust 1.26, you could
  just label that as `!` if you never return an error.

src/client/dispatch.rs

@@ -39,10 +39,10 @@ impl<T, U> Sender<T, U> {
                 // there's room in the queue, but does the Connection
                 // want a message yet?
                 self.giver.poll_want()
-                    .map_err(|_| ::Error::Closed)
+                    .map_err(|_| ::Error::new_closed())
             },
             Ok(Async::NotReady) => Ok(Async::NotReady),
-            Err(_) => Err(::Error::Closed),
+            Err(_) => Err(::Error::new_closed()),
         }
     }
 
@@ -184,9 +184,12 @@ mod tests {
             drop(rx);
 
             promise.then(|fulfilled| {
-                let res = fulfilled.expect("fulfilled");
-                match res.unwrap_err() {
-                    (::Error::Cancel(_), Some(_)) => (),
+                let err = fulfilled
+                    .expect("fulfilled")
+                    .expect_err("promise should error");
+
+                match (err.0.kind(), err.1) {
+                    (&::error::Kind::Canceled, Some(_)) => (),
                     e => panic!("expected Error::Cancel(_), found {:?}", e),
                 }