docs(frost/roast): document quorum-gate boundary behaviour and parking scope

Review follow-ups on the verifiable-blame revision:

- Fix inverted group-shape wording (51-of-100, not 100-of-51).
- State explicitly that near the assumption boundary the accuser
  quorum needs all but 2t-n-1 honest observers (50 of 51 at the
  production shape), so in the high-f regime the gate is a
  fabrication firewall rather than a working exclusion mechanism;
  proof-carrying blame restores exclusion there.
- Document the n-of-n edge of ExclusionAccuserQuorum (quorum 1,
  consistent with f = 0 under that shape's own assumption).
- Make precise that silence parking keys on bundle absence: a member
  that submits its evidence snapshot while withholding its signing
  contribution is not parked by this layer; that cost is bounded by
  the Annex B retry budget until t-of-included finalize.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: mswilkison

docs/rfc/rfc-21-roast-coordinator-retry-and-transition-evidence.adoc

@@ -348,12 +348,18 @@ honest.
   falsely labelled silent because their contribution arrived late (or
   because a malicious coordinator censored it) is not permanently
   penalised -- they are reinstated by the very next attempt.
+  Silence is detected as *bundle absence* (the member submitted no
+  evidence snapshot for the transition). A member that submits its
+  snapshot while withholding its signing contribution is therefore
+  not parked by this policy: signing-silence is invisible to the
+  transition layer, costs the attempt, and is bounded only by the
+  retry budget (Annex B) until t-of-included finalize lands.
 . If `IncludedSet` minus exclusions drops below the threshold `t`, the
   coordinator returns `ErrAttemptInfeasible` and the session is
   declared failed for this signer set.
 
 The quorum is a *derived constant* of the key-group shape -- for the
-production 100-of-51 group it is 50 -- so honest signers do not need
+production 51-of-100 group it is 50 -- so honest signers do not need
 to negotiate it and drift cannot desynchronise it. Sub-quorum claims
 are deliberately ignored rather than parked: acting on a single
 unverifiable claim would let one byzantine observer cost any honest
@@ -370,7 +376,14 @@ to proof-verified entries. The cost of the interim quorum policy is
 bounded: a fault observed by fewer than `f+1` honest members (for
 example a targeted, per-recipient equivocation) is not permanently
 excluded and instead burns retry attempts, which the serial-attempt
-latency analysis already budgets for.
+latency analysis already budgets for. Near the assumption boundary
+the gate is intentionally demanding -- at worst-case `f` only `t`
+honest observers exist, so establishment needs all but `2t-n-1` of
+them (50 of 51 at the production shape) to have observed the fault
+and landed snapshots in the bundle. In that regime the quorum acts
+as a fabrication firewall rather than a working exclusion mechanism;
+restoring per-category exclusion under heavy attack is exactly what
+proof-carrying blame is for.
 
 === Layer C: Retry orchestration (M7)
 

pkg/frost/roast/next_attempt.go

@@ -35,9 +35,23 @@ import (
 // against a quorum of 50, while the 49 worst-case byzantine members
 // can never reach 50 by fabrication.
 //
+// The gate is intentionally demanding near the assumption boundary:
+// at worst-case f = groupSize - threshold, only threshold honest
+// observers exist, so establishment needs all but 2t-n-1 of them
+// (50 of 51 at the production shape) to have observed the fault and
+// landed snapshots in the bundle. In that regime the quorum acts as
+// a fabrication firewall rather than a working exclusion mechanism;
+// real faults that fewer honest members observe burn retry attempts
+// instead (budgeted in RFC-21 Annex B), and proof-carrying blame
+// (see the roadmap in NextAttempt) is what restores per-category
+// exclusion there.
+//
 // A zero threshold (used by policy-only tests) or a threshold larger
 // than the group yields groupSize+1 -- deliberately unreachable, so no
-// accusation-driven action can occur without a real threshold.
+// accusation-driven action can occur without a real threshold. A
+// threshold equal to groupSize (n-of-n) yields a quorum of 1: under
+// that shape's own assumption every member is honest (f = 0), so a
+// single accusation is established by definition.
 func ExclusionAccuserQuorum(groupSize, threshold uint) uint {
 	if threshold == 0 || threshold > groupSize {
 		return groupSize + 1