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/io.rs

@@ -108,7 +108,7 @@ where
         }
     }
 
-    pub fn parse<S: Http1Transaction>(&mut self) -> Poll<MessageHead<S::Incoming>, ::Error> {
+    pub(super) fn parse<S: Http1Transaction>(&mut self) -> Poll<MessageHead<S::Incoming>, ::Error> {
         loop {
             match try!(S::parse(&mut self.read_buf)) {
                 Some((head, len)) => {
@@ -118,14 +118,14 @@ where
                 None => {
                     if self.read_buf.capacity() >= self.max_buf_size {
                         debug!("max_buf_size ({}) reached, closing", self.max_buf_size);
-                        return Err(::Error::TooLarge);
+                        return Err(::Error::new_too_large());
                     }
                 },
             }
-            match try_ready!(self.read_from_io()) {
+            match try_ready!(self.read_from_io().map_err(::Error::new_io)) {
                 0 => {
                     trace!("parse eof");
-                    return Err(::Error::Incomplete);
+                    return Err(::Error::new_incomplete());
                 }
                 _ => {},
             }