feat: rotating talking stick, so agents read before they write

[obeone]

What changed

A scope can now run a rotating talking stick instead of an exclusive one:
floor(action="round", scope=...) opens a round-table, and the stick moves when
you speak.

The exclusive stick we already had solves "let one agent finish". It does nothing
about the failure that actually hurts in a busy room: every agent composing its
reply against a half-read exchange, in parallel, then firing them all at once.
Refusing the send was never enough, because by the time the 423 comes back the
reply is already written and the turn is already spent.

A round inverts that. While it is not your turn the hub withholds that scope's
traffic from you, so there is nothing to pre-compose against. When the stick
reaches you, you get the whole accumulated backlog in one batch followed by a
"you have the floor, deadline in N s" marker, and you read before you write.

Rotating costs no extra tool call: one say() routes the message, hands the stick
on, and returns the new floor state in its own result. Two variants cover the
times you are not ready:

• say(turn="pass") is "nothing to add" and rotates immediately.
• say(turn="extend") is "still thinking". It buys more time and reaches nobody.

That last guarantee is structural rather than a filter someone can regress later:
pass and extend post to /floor, so they never touch /send at all.

Order is room-join order in a live ring. A peer arriving mid-round takes the tail,
one that leaves drops out, one the operator paused is skipped and keeps its place.
The operator is never in the ring and can always speak. A turn lasts 300s with
unlimited 180s extensions, and one full lap with nobody speaking closes the round
on its own.

Extensions being unlimited means a holder can hold up the table, so the design
makes that visible instead of impossible: the count rides every floor event,
crossing three announces itself to the room, and the console gains Skip turn and
End round next to the existing Clear stick.

Operator side

The floor strip shows the ring, the current speaker, a live countdown, the
extension count, and how much traffic the hub is holding back. That last figure is
what lets a human tell a peer waiting its turn from a peer that has died, which
retention otherwise makes indistinguishable. For the same reason the peers panel
says "waiting its turn" rather than flagging a correctly parked peer as quiet.

Protocol

Revision 25. The always-on PROTOCOL_TEXT grows by 335 characters, which pushes
it past the 6600 ceiling, so the ceiling moves to 6900. Same call revision 24 made
for the channel-has-no-history warning, and for the same kind of reason: an agent
that does not know rounds exist reads a withheld lane as a dead room and gives up
on it. That cannot live in the on-demand section alone.

New knobs

--round-turn-seconds / CAUCUS_ROUND_TURN_SECONDS and
--round-extend-seconds / CAUCUS_ROUND_EXTEND_SECONDS.

Design notes worth a reviewer's attention

Retention lives in route(), not in /receive. A poll-side gate looked
obvious and does not survive contact: Client.queue is one FIFO carrying DMs,
other channels and hub notices together, so the gate would have to drain and
partition the whole queue on every poll, and it hot-spins because the chatter
getter completes the instant a withheld message lands. Worse, any hole in such a
filter wakes watch.py, which exits on its first emitted message and burns an
agent turn on a fragment of the conversation. Withholding at routing time leaves
the parked peer's queue genuinely empty for that scope, so its watcher long-polls
in silence and its last_seen stays fresh.

The flush and the turn grant must land in one /receive batch. _grant_turn
has no await between them on purpose. Adding one splits the transcript across
two polls and wakes the agent twice on half a conversation, which is the exact
failure this feature exists to prevent. There is a comment saying so and an
end-to-end test pinning it.

Rotations are a direct message to the incoming holder, never a scope-wide
announce. _announce_floor routes into every member's queue, so announcing each
rotation would wake every parked watcher on every turn. Only opening and closing a
round are announced to the room.

A round is not a third brake. Pause and stop still cut straight through it, and
stop flushes every withheld backlog before clearing the floors.

Three bugs the new tests found

1. The silent-lap counter counted turns rather than peers. With a ring of two,
   three passes taken by the two original members satisfied a count of three, so a
   peer that joined mid-lap was closed out without ever holding the stick. It is
   now the set of peers that have declined, and the question asked is "has everyone
   still able to speak declined?", which a newcomer cannot falsify.
2. A graceful leave did not release what a round was holding for it.
   _relinquish_floor looks the peer up in the roster or the graveyard, and a
   terminal drop is in neither by then. Latent rather than live (the record is
   discarded with its queue anyway), but the docstring claimed otherwise.
3. A round opened from the console was credited to the first seeded peer instead of
   the operator, in the room announce and in the first floor event both.

How I verified it

ruff check src/                 clean
mypy src/                       clean, strict, 19 files
pytest                          1201 passed (1083 before this branch)
cd web && npm test              227 passed, 14 files
cd web && npm run build         clean, assets committed

Plus a manual pass against a running hub, which is the part I actually trust for
this one. With CAUCUS_ROUND_TURN_SECONDS turned down: a parked peer's /receive
returns 0 messages while the stick is elsewhere, then returns the backlog and the
grant in a single batch with ascending seq and the grant last; extend pushes
the deadline and routes nothing; the sweep rotates an expired turn on its own (two
expiries logged); declined fills up peer by peer until the lap closes the round.

npm run lint does not run: eslint is in the lint script but not in
devDependencies, and CI never calls it. That is broken on main already and I
left it alone rather than widening this PR.

The analysis, the implementation and the tests were done with Claude Code.

Checklist

• User-visible changes are recorded under ## [Unreleased] in CHANGELOG.md.
• PROTOCOL_TEXT changed, and PROTOCOL_VERSION went 24 to 25.