mu.lock: after acquiring m.ch, why does the re-check only look at closed and not ctx?

Hi, I was looking at [mu.lock](https://github.com/coder/websocket/blob/master/conn.go#L286) and had a question about this part:

```go
func (m *mu) lock(ctx context.Context) error {
select {
case <-m.c.closed:
return net.ErrClosed
case <-ctx.Done():
return fmt.Errorf("failed to acquire lock: %w", ctx.Err())
case m.ch <- struct{}{}:
// To make sure the connection is certainly alive.
// As it's possible the send on m.ch was selected
// over the receive on closed.
select {
case <-m.c.closed:
// Make sure to release.
m.unlock()
return net.ErrClosed
default:
}
return nil
}
}
```

After acquiring the lock, `closed` is checked again in case both branches were ready.

Why isn't `ctx.Done()` checked here as well?

Could `ctx` be canceled right after `m.ch` is selected, causing `lock` to return `nil` while holding the lock with an already-canceled context?

Commencez dans conn.go, autour de mu.lock à la ligne 286, et suivez comment son contexte et les channels fermés sont utilisés par les appelants. Comparez le comportement de l’annulation et de l’acquisition du lock, puis déterminez si le cas signalé nécessite une modification du code ou de la documentation ; le travail est terminé lorsque la question de l’issue a reçu une réponse avec une justification reproductible.

Rédigé par le modèle d'indexation à partir du texte de l'issue.