Keep file-gated reviewers on an empty diff; narrow the reviewer set across rounds

[adamw]

Two independent defects in reviewer selection, in the same two files.

1. An empty diff silently dropped file-gated reviewers

reviewAndFixLoop derives changedFiles from the review diff, which is Nil
whenever that diff is empty. ReviewerSelector.agentDriven then filtered
candidates by their files: pattern, so scala-fp (today the only reviewer
declaring one) was removed before the picker ever saw it: on a Scala change with
an empty diff, the Scala reviewer simply did not run. The safety floor could not
restore it, because it falls back to eligible, not all.

An empty change set now means "which files changed is unknown", not "no files
changed": the pre-filter is skipped and an OrcaEvent.Step names the reviewers
it kept eligible.

2. The reviewer set never narrowed across rounds

agentDriven.prepare computed its pick once and returned _ => active,
discarding the review history it was handed — so every picked reviewer ran in
every round of the fix loop, whether or not it had anything left to say. A
measured run spent 11 rounds this way.

New combinator ReviewerSelector.narrowingAcrossRounds(base): round one runs
base's pick; every later round keeps only those of base's reviewers that
reported an issue in the previous round. It only ever filters base's result,
so a reviewer the picker excluded is never resurrected. A reviewer that reported
is the one whose finding the fixer just acted on, so it must re-check its own
verdict; everything else would re-read an unchanged verdict at a full turn's
cost per round.

Narrowing never empties a non-empty set. Reviewer silence alone ends the loop,
but a lint gate keeps it iterating through silence while the fixer edits;
without a floor the narrowed set is absorbing and later rounds run zero
reviewers. When narrowing would leave none, base's pick runs again and a
Step says so.

A files: pattern gates eligibility only

Per ADR 0011 the files: frontmatter exists to keep a language-specific
reviewer off changes it cannot speak to — it is a relevance filter, not a
priority signal. So it grants no exemption from narrowing: a quiet scala-fp is
dropped like any other quiet reviewer. Since narrowing only ever filters the
picker's own result, such an exemption could in any case only retain an
already-picked reviewer; it never re-admitted one the picker had excluded.

Dropping it removes narrowingAcrossRounds's filePatterns parameter and the
four-case FileClaim enum, which existed only to answer the eligibility and
narrowing questions differently. One question is left, so eligibility is one
predicate.

It also leaves changedFiles with exactly one consumer —
ReviewerSelector.prepare, which runs once, at loop start (ADR 0011: the
per-round arrow is pure and cannot re-sample the diff). The loop-start diff
sample can therefore no longer go stale against a later round's edits.

Default, not opt-in

ReviewerSelector.default (= narrowingAcrossRounds(agentDriven)) is now
reviewAndFixLoop's shipped default, replacing bare agentDriven.

The evidence for not shipping this as opt-in is in this repo:
ReviewerSelector.onlyPreviouslyReporting has implemented narrowing for a while
and no shipped flow uses it — implement.sc, implement-enhanced.sc,
issue-pr.sc and issue-pr-bugfix.sc all take the default. Another opt-in
would change nothing for anyone. The cost this removes is the dominant term in a
review stage (reviewers × rounds), and the narrowing rule is conservative on the
axis that matters: the reviewer that raised an issue always re-checks the fix.

What is given up is stated plainly in the README and the scaladoc: a reviewer
that goes quiet won't see fixes made after it stopped running.
ReviewerSelector.allEveryRound remains the one-word opt-out for flows that
want regression coverage over tokens, and agentDriven(model) still means "pick
once, replay every round" for anyone who wants exactly today's behaviour with a
chosen picker.

Expected effect on review rounds

Round one is unchanged (picker output, now including file-gated reviewers that
an empty diff used to hide). From round two on, the active set is the previous
round's reporters — in a converging loop that shrinks toward the one or two
reviewers still finding things, instead of staying at the full picked set for
every round. Rounds themselves are not capped by this change.

Regression guarded

A reviewer dropped in round two must still contribute its retained
gateRejects to the final IgnoredIssues — that is exactly why the loop keeps
each agent's last-seen rejects. The test pinning it now drives the shipped
default (the bespoke first-round-only selector it used is gone), so the
guarantee is asserted against the behaviour users actually get.

Known limitation, not addressed here

The diff both the selection and the reviewer prompts are built from is
git.reviewDiff() — git diff HEAD plus untracked file contents. It is
therefore empty whenever the implementing agent has committed its own work, and
reviewer selection then runs on an empty change set while every first-time
reviewer is prompted with "(no diff captured — review the working tree)". The
mitigation above (an empty change set no longer drops file-gated reviewers)
limits the damage but does not fix the cause.

Fixing it properly needs a base commit to diff against, and the natural one —
HEAD as the enclosing stage began — is recorded nowhere: neither FlowContext
nor ProgressHeader nor StageFrames carries it, and startingBranch is not a
substitute (in skip-branch mode it is the current branch). That is
cross-cutting plumbing rather than a change to these two files, so it is left
out of this PR. initialDiff = Some(...) remains the per-call escape hatch.

Tests

• ReviewerSelectorTest: an empty diff keeps file-pattern reviewers eligible
  and announces the skipped filter; narrowing re-runs only the previous round's
  reporters, never empties the active set, and never resurrects a reviewer the
  base excluded.
• ReviewAndFixTest: in a three-round loop a reviewer that reports nothing in
  round one opens exactly one session; a gate reject survives its reviewer being
  narrowed out; a lint-only round still leaves the next round with reviewers.

sbt scalafmtCheckAll and sbt clean compile test are green with zero
warnings; every behavioural change above is mutation-checked.