fix: detached-stream lifecycle follow-ups on all four engines

[FumingPower3925]

Closes #498.

Five defects from the #496 review, each confirmed real and fixed with a fail-first test. They share a shape: a detached stream is not told when its peer goes away, or is not cleaned up when it does.

1. H2/h2c SSE was not covered at all

Manager.Close is the only teardown an H2 stream gets when its connection dies — both native engines reach it from closeConn via CloseH2 — and it skipped Cancel() for streams whose handler was still running on the H2 worker pool, which is exactly the SSE ones. Nothing ever cancelled them.

This is worse than the H1 leak it mirrors: the H2 worker pool is process-global, so parked handlers go on to starve every later H2 connection.

Cancel() signals; Release stays deferred to the goroutine that owns the stream.

2. epoll skipped EPOLLRDHUP for every detached conn

That is right when the FIN arrives on its own readable edge — drainRead's Read returns 0 and the existing EOF path fires OnError(errPeerClosed). It is wrong when it does not, so an SSE conn whose handler never writes never learns the peer left.

Now fires OnError under detachMu for detached conns with no WebSocket sink. WebSocket conns keep their current behaviour — their middleware genuinely does own the close lifecycle.

3. std Shutdown cancelled nothing

http.Server.Shutdown only waits for connections to go idle. A context-only SSE handler ran straight through it.

Wired a BaseContext cancelled on shutdown, so handlers wake cooperatively and in-flight non-detached requests still drain normally — rather than yanking connections with server.Close().

4. io_uring never reaped a closing detached conn with undrained sends

closeConn defers the fd close while a SEND is outstanding and sets cs.closing; checkTimeouts skipped cs.closing conns, so the only exit was the SEND's own CQE. A peer that stops reading held the connection until it disconnected. Added a bounded closing timeout in checkTimeouts.

5. epoll could drop the terminal chunk

After the idle-deadline reap, closeConn took SHUT_WR without a final flush, so a remainder stuck on EAGAIN was lost. Now attempts one flushWrites under detachMu for truly-detached conns first.

Verification

Each item was developed in an isolated worktree with a fail-first test, then integrated here. On msa2-server (amd64, kernel 7.0.0-30):

engine/epoll       PASS
engine/iouring     PASS
middleware/sse     PASS

Plus root, protocol/h2/stream and engine/std green on darwin; gofmt, go vet and cross-compiled linux build all clean.

Note

Touches engine/iouring/worker.go in closeConn/checkTimeouts, which is a different region from the drainDetachQueue change in #516 — they should not conflict, but #516 is the more urgent of the two since it fixes a regression currently on main.