Memory leak with HttpRequestRef.getBody proc
When reading a full request body to memory, ~4x the memory is allocated and is never freed, even after running `GC_runOrc`.

Compiler flags: `--threads:on --mm:orc `

Nim version: `1.16.12` (latest stable)
OS: ArchLinux running `linux 6.2.9.arch1-1`

Reproduction instructions:

```shell
# Start the server in another terminal and notice it's using less than 1MiB RAM

# Create a 100MiB file
fallocate -l 100M /tmp/100m

# Send the 100MiB file verbatim
# It also works with form data using the HttpRequestRef.post proc, memory usage may be worse for that, too
curl -i -X POST 'http://localhost:8080/' --data-binary '@/tmp/100m'

# Notice that the server is now using over 400MiB RAM, and it never gets freed, even after manual ORC collections
```

Reproduction program:

```nim
import std/[os]
import chronos, chronos/apps/http/httpserver

proc server() {.thread.} =
    ## Server thread
    
    proc handler(rf: RequestFence): Future[HttpResponseRef] {.async.} =
        if not rf.isOk:
            return dumbResponse()

        let req = rf.get()

        let bodyRaw = await req.getBody()

        return await req.respond(Http200, "Body length: " & $bodyRaw.len)
    
    var serverRes = HttpServerRef.new(
        initTAddress("127.0.0.1", 8080),
        handler,
        maxRequestBodySize = 1024 * 1024 * 1024,
        socketFlags = {ServerFlags.TcpNoDelay, ServerFlags.ReuseAddr, ServerFlags.ReusePort},
    )

    if serverRes.isErr:
        echo "ERR!"
        quit 1

    let server = serverRes.get()

    server.start()
    runForever()

var serverThread: Thread[void]
createThread(serverThread, server)

proc gc() {.thread.} =
    ## Garbage collector thread
    
    while true:
        # Sleep for 10s and then do full collect
        sleep(10_000)
        GC_runOrc()
        echo "Ran full collect"

var gcThread: Thread[void]
createThread(gcThread, gc)

runForever()
```

I've also noticed that simple allocations in the request body also often don't get freed.

Allocating 100MiB with `let str = newString(1024 * 1024 * 100)` doesn't get freed (under refc it actually takes up more space) but doesn't grow past the first request usually. If you allocate 1GiB with `let str = newString(1024 * 1024 * 1024)` though, it immediately gets freed (except on refc, where it stays allocated forever). 