Add lightweight write deadlines to Conn

### Problem

Long-lived WebSocket servers often need every outbound write to be bounded. With `v1.8.15`, the main API requires creating a deadline context for every message:

```go
package main

import (
"context"
"log"
"net/http"
"time"

"github.com/coder/websocket"
)

func main() {
http.HandleFunc("/", serve)
log.Fatal(http.ListenAndServe(":8080", nil))
}

func serve(w http.ResponseWriter, r *http.Request) {
c, err := websocket.Accept(w, r, nil)
if err != nil {
return
}
defer c.CloseNow()

connCtx := c.CloseRead(r.Context())
ticker := time.NewTicker(10 * time.Millisecond)
defer ticker.Stop()

for {
select {
case <-connCtx.Done():
return
case <-ticker.C:
ctx, cancel := context.WithTimeout(context.Background(), time.Second)
err := c.Write(ctx, websocket.MessageText, []byte(`{"type":"event"}`))
cancel()
if err != nil {
return
}
}
}
}
```

Using `context.Background()` avoids the timeout-related allocations added around each frame, but also removes the bounded-write guarantee.

`websocket.NetConn` exposes `SetWriteDeadline`, but it is a full bidirectional adapter. It creates read and write contexts, timers, and locks, and calls `SetReadLimit(-1)` even when only its write side is needed.

A loopback benchmark with `v1.8.15` on Go 1.27rc2 produced:

| Strategy | Write path | Connection construction |
|---|---:|---:|
| `context.WithTimeout` | 1304 B/op, 12 allocs/op | no extra adapter |
| `NetConn.SetWriteDeadline` | 664 B/op, 5 allocs/op | 848 B, 13 allocs |

The write measurements use the same client reader, so the allocation difference is the relevant result. At high connection counts, the fixed `NetConn` cost is material.

### Request

Could `*websocket.Conn` provide a lightweight write-only deadline mechanism, for example `SetWriteDeadline(time.Time)` or an equivalent API?

Ideally it would:

- reuse connection-owned deadline state instead of allocating a timer context per write;
- bound both write-lock acquisition and the underlying write;
- preserve the current behavior where a timed-out write closes the WebSocket;
- remain safe with concurrent `Ping`, `Close`, and data writes;
- avoid creating read-side state or changing the configured read limit;
- allow zero time to clear the deadline.

Related: #252 discusses the same API direction for read deadlines.

Inspect the write path on *websocket.Conn and the deadline handling in websocket.NetConn first, then read related issue #252 for the read-deadline direction. Done means a write-only deadline mechanism that bounds lock acquisition and writes, preserves timeout-close behavior, remains safe with concurrent operations, avoids read-side state, and clears on a zero time.

Scritto dal modello di indicizzazione a partire dal testo della issue.