* chore(ci): Use hashbrown 0.15.0 in MSRV check

* chore(ci): Use stable rust to resolve dependency

…n mpsc channel (#159)

Co-authored-by: JESS IZEN <jlizen@amazon.com>

Closes hyperium/hyper#3817

…pport are enabled (#164)

…ams`, and `ignore_invalid_headers`. (#161)

…okioExecutor (#166)

there is a module-wide allowance for dead code that seems to be a
holdover from when this was initially being written.

removing this does not unearth any warnings, and ideally any future
additions can be explicitly, and more narrowly, annotated accordingly if
need be.

Signed-off-by: katelyn martin <me+cratelyn@katelyn.world>

this function is not used, and a warning is observed when this crate is
built with e.g. `--all-features`.

this commit removes this unused method from the `PoolClient<B>` type.

Signed-off-by: katelyn martin <me+cratelyn@katelyn.world>

this commit introduces two new i/o adaptors, akin to
`rt::tokio::TokioIo<I>`.

see this small program demonstrating the motivation for this:

```rust
 #![allow(unreachable_code, unused_variables, dead_code)]

 use {
     hyper::rt::{Read, Write},
     hyper_util::rt::TokioIo,
     tokio::io::{AsyncRead, AsyncWrite},
     tokio::net::TcpStream,
 };

 fn is_tokio_io<I>(_: &I)
 where
     I: AsyncRead + AsyncWrite,
 {
 }

 fn is_hyper_io<I>(_: &I)
 where
     I: Read + Write,
 {
 }

 fn check_io_impls() {
     // `I: AsyncRead + AsyncWrite` does not implement hyper's `Read` and `Write`.
     let stream: TcpStream = todo!();
     is_tokio_io(&stream);
     // is_hyper_io(&stream); does not compile

     // `TokioIo<I: AsyncRead + AsyncWrite>` does not implement `tokio::io` traits.
     let stream: TokioIo<TcpStream> = TokioIo::new(stream);
     // is_tokio_io(&stream); does not compile
     is_hyper_io(&stream);

     // `TokioIo<TokioIo<I: AsyncRead + AsyncWrite>>` does not implement hyper's `Read` and `Write`.
     let stream: TokioIo<TokioIo<TcpStream>> = TokioIo::new(stream);
     is_tokio_io(&stream);
     // is_hyper_io(&stream); does not compile
 }

 fn main() {}
```

`TokioIo<I>` is not an adaptor that is additive with respect to its
inner i/o transport. if it implements hyper's i/o, the wrapped type will
implement tokio's _at the expense of hyper's_, and vice versa.

this is often fine for simple programs, but this "switching" approach
can interfere with larger applications' ability to make use of
middleware that is generic across different kinds of i/o streams.

this commit introduces types that allow a caller to _add_ `Read` or
`Write` implementations to tokio readers and writers, or inversely,
`AsyncRead` and `AsyncWrite` implementations to hyper readers and
writers.

Signed-off-by: katelyn martin <me+cratelyn@katelyn.world>

…#177)

… systems (#176)