Hijacking FastHTTP connection to use `coder/websocket`?

Hello,

Instead of the Go standard `net/http`, I am using [FastHTTP](https://github.com/valyala/fasthttp) as my webserver, in order to upgrade to websockets using [FastHTTP websocket](https://github.com/fasthttp/websocket). It currently looks something like this, which is called by the GET handler of my FastHTTP server:

```
func websocketUpgradeHandler(ctx *fasthttp.RequestCtx) {
logger.Infof("Received WS request on %s", string(ctx.Path()))

// Upgrade the connection to a websocket.
err := websockets.Upgrader.Upgrade(ctx, func(conn *websocket.Conn) {
// Create a new WS connection object and give it the new WS connection.
wsConnection := &websockets.WSConnection{Conn: conn}

// Start the inbound WS worker goroutine.
wsConnection.WSInboundWorker()
})
if err != nil {
logger.Errorf("Failed to upgrade WS connection: %s", err)
}
}
```

According to [#229 (https://github.com/coder/websocket/issues/229), this should be doable with using FastHttp's `fasthttp#RequestCtx.Hijack`. From what I can tell, this will return the request context's underlying `net.Conn` object.

I am not sure how to make use of this within this websocket library. One total guess is somehow using `websocket.Accept`, but I don't know how to provide the required `ResponseWriter` and `Request`.

Some guidance on this would be much appreciated!

Start by reviewing FastHTTP's RequestCtx.Hijack and the websocket.Accept API mentioned in the issue, focusing on how the hijacked net.Conn could be passed into the library. Determine how the required ResponseWriter and Request would be represented, then verify that a FastHTTP GET handler can complete a WebSocket upgrade and serve a connection.

Vom Indexierungsmodell aus dem Issue-Text verfasst.