Document how to have read timeout be larger than idle timeout

Hi! Thanks for this excellent library.

I have a use case where I want the server to wait up to 10 seconds for the client to start sending data. If the server doesn't get a new Reader within that time, it closes the connection and bails.

However, if the client *does* start sending data, then they have a much longer time limit to finish sending. Say 2 minutes. As far as I can tell, there's not a good way to accomplish this with the current API design.

I saw this issue: https://github.com/nhooyr/websocket/issues/87

Which works IFF the idle timeout is larger than the read timeout.

This is because the `Conn.msgReader` holds on to the context passed in during `Reader()` Example:

```
ctx, cancel := context.WithTimeout(rootCtx, 10 *second)
defer cancel()

_, reader, err := ws.Reader(ctx)
if err != nil {
// Err handling....
log.Error(err)
return
}

// If reading data takes longer than 10 seconds, the timeout above will fire, and the context will be cancelled
// Killing the connnection
data, err := io.ReadAll(reader)
if err != nil {
// Err handling....
log.Error(err)
return
}
```

I can potentially work around this. Instead of using `context.WithTimeout`, I could just use `context.WithCancel`. Then have a `time.AfterFunc()`, which uses atomics to check if we got the reader already. In which case, don't cancel. Example:

```
ctx, cancel := context.WithCancel(rootCtx)
defer cancel()

gotReader := atomic.Bool{}

time.AfterFunc(10*time.Second, func() {
if !gotReader.Load() {
cancel()
}
})

_, reader, err := ws.Reader(ctx)
if err != nil {
// Err handling....
log.Error(err)
return
}
gotReader.Store(true)

time.AfterFunc(2*time.Minute, func() {
cancel()
})

data, err := io.ReadAll(reader)
if err != nil {
// Err handling....
log.Error(err)
return
}
```

I'm not sure what the best way to modify the API would be. You're unfortunately stuck with the io.Reader interface, without the ability to add a context. Thoughts?

Start by reading the Reader entry point and Conn.msgReader, then review the linked issue 87 and the context behavior shown in the examples. Determine whether the current API can support separate time limits for obtaining a Reader and finishing a read, and document the supported approach or the required API design change.

Written by the indexing model from the issue text.