Crosstalk between different HTTP requests
When running the following code, the last call to the long running request `/read` will also receive all the data from previous (interrupted) calls to`/read` (see assert in line 25). You need the head version of jester to compile this test code.

```nim
import jester
import httpClient
import strutils
import asyncfutures
import asyncdispatch
import nativesockets, httpbeast

let lines = 100
let message = "Hello World\r\n"

proc interruptedRead() {.async} =
    let client = newAsyncHttpClient()
    let future = client.get("http://localhost:5000/read")
    discard await future
    client.close()

proc read() {.async} =
    let client = newAsyncHttpClient()
    let future = client.get("http://localhost:5000/read")
    let response = await future
    let body = response.bodyStream
    var len = 0
    while true:
        let (hasData,msg) = await body.read()
        if not hasData: break
        len += msg.len()
        assert(len <= 5 * lines * message.len())
    client.close()

proc write() {.async} =
    let client = newAsyncHttpClient()
    discard await client.get("http://localhost:5000/write")
    client.close()

proc test() {.async} =
    await sleepAsync(1000)
    for i in 0..10:
        await interruptedRead()
    asyncCheck read()
    asyncCheck write()

asyncCheck test()


var subscriptions: seq[FutureStream[string]]

routes:
  get "/write":
      for s in subscriptions:
        for i in 0..lines:
            await s.write(message)
      resp "OK\r\n"

  get "/read":
    enableRawMode()
    request.sendHeaders(Http200,@({"Content-Type": "text/plain"}))
    let stream = newFutureStream[string]()
    subscriptions.add(stream)
    while true:
        let (hasData, message) = await stream.read()
        if not hasData:
            break
        request.send(message)
    for i in 0..subscriptions.len():
        if subscriptions[i] == stream:
            subscriptions.del(i)
    request.close()
    break route
```

I also saw that data written into one of the `subscriptions` `FuturesStream`s is returned in the call to `/write` (even before the HTTP header!). But I was not able to reproduce this with a simple example.


It seems that the `request` object is somehow shared between different HTTP requests running at the same time ?? Or am I doing something wrong?