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/proto/h1/conn.rs

@@ -20,7 +20,7 @@ use super::{EncodedBuf, Encoder, Decoder};
 /// The connection will determine when a message begins and ends as well as
 /// determine if this connection can be kept alive after the message,
 /// or if it is complete.
-pub struct Conn<I, B, T> {
+pub(crate) struct Conn<I, B, T> {
     io: Buffered<I, EncodedBuf<Cursor<B>>>,
     state: State,
     _marker: PhantomData<T>
@@ -146,7 +146,8 @@ where I: AsyncRead + AsyncWrite,
                 _ => {
                     error!("unimplemented HTTP Version = {:?}", version);
                     self.state.close_read();
-                    return Err(::Error::Version);
+                    //TODO: replace this with a more descriptive error
+                    return Err(::Error::new_version());
                 }
             };
             self.state.version = version;
@@ -245,7 +246,7 @@ where I: AsyncRead + AsyncWrite,
         if self.is_mid_message() {
             self.maybe_park_read();
         } else {
-            self.require_empty_read()?;
+            self.require_empty_read().map_err(::Error::new_io)?;
         }
         Ok(())
     }