Refactor code to enable persistent connections and pipelining

* While persistent connections should work, we need to audit
  ourselves to ensure that we're actually compliant with the RFC.
* Pipelining is currently supported but requests are still being
  processed serially.
Remove a small note, asyncio.async appears to be working fine
Handle persistent connections correctly

* Send Connection: close on our final request
* Respect Connection: close when given to us by a client
* Assume Connection: close when the client is using HTTP/1.0
We want to process responses while unless we're closed *or* not empty
Instead of tracking the final request, just close the queue.
Ensure that Content-Length (or lack thereof) on a Response is handled

* If the application provides a content length, then we trust it and
  simply use that.
* If the application does not provide a content length, but the
  iterable that it gave us has a length of zero, then there is no
  body and we infer a content length of 0.
* If the application does not provide a content length, but the
  iterable that it gave us has a length of one, then there is a
  body and it is a single chunk, so we can get that chunk and
  use the length of that.
* Otherwise we have no way of determining what the length should
  be without buffering the entire response into memory, so we treat
  this like HTTP/1.0 and we close the connection after this response.