fix: reload associated Requests on Session.Close before their WebSocket subscribes

[linkdata]

Summary

Fixes #215. Session.Close documents that Requests already associated with the Session "will ask the browser to reload the pages", but it delivered the reload only through a key-targeted Jaws.Broadcast. The serve loop's mustBroadcast fans out only to Requests present in its subscription map at that instant, so a Request in its pending window — page rendered by NewRequest, but its /jaws/<key> WebSocket has not yet reached subscribe — never received the reload. deadSession also cleared rq.session, so the Request kept no record of the close and never reloaded when it finally connected. The page kept running stale authenticated UI after logout / credential rotation.

This is distinct from #161, which covered broadcasts issued from ConnectFn (after the subscription exists); #215 is about a reload sent before the WebSocket request begins at all.

Approach

• deadSession now queues exactly one Reload frame directly onto the Request's wsQueue, under the rq.mu it already holds. process drains wsQueue before its first select, so the reload is delivered as soon as the WebSocket connects — independent of subscription timing. Holding rq.mu excludes a concurrent recycle and the process loop's getSendMsgs, so the append is safe (rq.mu → muQueue order).
• Session.Close broadcasts a key-targeted what.Update purely as a wake-up: it makes an already-running process loop iterate and flush the queued reload. handleBroadcast resolves a key destination to no elements, so the Update itself performs no browser operation — exactly one reload is delivered on every path (no duplicate window.location.reload()).
• mustBroadcast overload classification: only the internal periodic dirty-render tick (a nil-destination Update) is droppable. distributeDirt has already moved the dirty tags into each Request's todoDirt and cleared the global set, so the tick carries no payload — it only nudges the Request. The dirt is still rendered without it in both phases: a Request already in its process loop is woken by the message that filled the channel and drains todoDirt on the next pass, and one still starting up (subscribed before onConnect) drains todoDirt on its first pass without needing a wake. Every addressed message now fails-fast an overloaded Request with ErrRequestOverloaded, including a tag-targeted Update (one-shot; this also fixes a pre-existing latent loss of tag-targeted Updates under backlog) and the key-targeted Update wake-up. The check is a plain msg.Dest != nil, so lib/key is no longer imported by serve.go.

Note: Session.Broadcast addresses by key, so Session.Broadcast(Update) is fail-fast rather than droppable — consistent with the rule that only the internal nil-destination tick is coalescible.

Docs updated to match: Session.Close, deadSession, mustBroadcast, the runWebSocket buffer comment, and ErrRequestOverloaded (which now notes the one droppable exception).

Tests

• TestSessionCloseReloadsAssociatedPendingRequest — deterministic regression test for the pending path: a drained control subscription proves (via broadcast ordering) that Close's wake was processed while the target had no subscription, then the target dials and exactly one Reload is asserted by reading through a post-connect marker and counting every Reload operation. Confirmed to fail on the pre-fix code.
• TestSessionCloseReloadsConnectedRequestExactlyOnce — connected path: closes the session while the Request is connected, then reads through a post-close marker and asserts exactly one Reload, so a delayed duplicate would be caught (a single-frame read could miss one).
• TestServeKeyTargetedUpdateFailFast — covers all three destination classes: a nil-destination Update overload leaves the Request alive and proves the subscription survived (drains the tick, then a targeted message must still arrive); a tag-targeted Update overload and a key-targeted Update overload each fail-fast with ErrRequestOverloaded.
• TestSession_ProducersSkipRecycled — updated to expect the Update wake, assert exactly one queued Reload on the live Request, and assert the recycled request's queue stays empty.
• TestSession_Delete and TestSessionCloseDoesNotReachLaterRequest — preserved.

Mutation-checked: all-Updates-droppable, killSub-without-cancel on the droppable path, and a duplicate queued reload each fail the new assertions.

Verification

go test -race ./..., go test ./... (release renderer), go vet ./..., gofmt -l ., and staticcheck ./... all pass. deadSession, Session.Close, and ServeWithTimeout report 100% coverage; the targeted tests pass repeatedly with no flakiness.