Give repetition, exchange and drains forms of their own

[zmaril]

Stacked on #43. Normalization only — no findings change in this PR on either
corpus. It is vocabulary, and two of the three laws are reported with the number
they actually moved, including one that is zero.

Repeat and Swap

Three of seven hand-written sort spellings were opaque at the top, because a
while was raw syntax and described no work at all: a library function that
loops that way yielded no behavior. Repeat holds the construct, and a loop
is the same construct with its condition written inside as a break — so
loop { if done { break } .. } reduces to while !done { .. }. A loop with a
second way out keeps its shape, because hoisting only the first test would claim
it runs longer than it does.

Swap is the operation every naive sort is built from. v.swap(i, j) and the
three statements through a temporary shared no subterm; the corpus writes the
second 131 times. With those, and a group of one step reducing to that step,
the two spellings of a bubble sort reduce to one form. That is not sort
detection and should not be mistaken for it — it means the shape space stopped
growing with the spelling.

The counted loop — correct, and it absorbs nothing

let mut i = 0; while i < n { .. ; i += 1 } is for i in 0..n. This law only
has to reach a walk over a span; the element-traversal law from #41 takes it the
rest of the way, so the while spelling lands on the identical form the for
spelling does, and a loop with a leading break reaches it through four laws.

Unlike every other law here it is not local to a node: the span's START is in
the binding before the loop, so the two have to be seen together.

Writing down where the step sits found a bug in the first version. Counting
up, the increment goes last and the walk is a..n. Counting down, the decrement
goes FIRST — that is what keeps the index in range and how the loop is written —
and the walk is the same span the other way about. The other two placements
visit different spans and are refused. rev now flips a walk's direction too,
which nothing produced before.

MEASURED, AND THE NUMBER IS ZERO. Across 727 CodeNet files it absorbs no
repetitions: 590 hold one with the law and 590 without. The reason is plain in
what those loops are — 434 are loop with the exit deeper in, and most of the
rest are binary searches and two-pointer walks whose index jumps rather than
steps. In 575 functions of production Rust only 15 repetitions survive and 13
are while let. Rust programmers write for when they mean a counted loop.

Kept because it is correct, costs nothing, and a while-spelled distinctness or
sortedness check is now recognized where it was not — both verified end to end.
Reviewers may reasonably disagree and I would not argue hard for it.

while let, and the drain — this is where the loops were

while let P = e { b } is loop { match e { P => b, _ => break } }, the
desugaring the language performs. Writing it out fixes something worse than a
missing law: the condition was normalized as an expression, so the name the
pattern binds came out a free variable — a hole matching anything, where the
body reads a binding.

as_drain then reads taking from a container until it is empty as walking it,
so while let Some(x) = queue.pop_front(), while let Some(x) = it.next() and
for x in queue reduce to one form.

Two refusals carry it, both measured first:

• a body that puts something back is a worklist, not a drain, and its elements
  are not the ones the container started with — 1,353 against 583
• a bare pop is not taken at all, because the name settles no order: it is the
  last element of a Vec and the greatest of a BinaryHeap. Of the 931
  files draining with pop, 434 also use a BinaryHeap. Calling a heap's
  drain a backward walk would report the opposite order, which is the one thing
  Direction exists to prevent.

Measured on the population it is for: across 900 files that drain with
pop_front, pop_back or next, repetitions fall from 1,291 to 1,131. 160
loops that were opaque are now traversals.

Review notes

• 355 tests, clippy clean.
• Clippy scoreboard unchanged at 26/201, 36/36 on-target — verified against the
  base commit, so no regression. It is also no gain, and that is expected:
  needless_range_loop and manual_while_let_some are style lints about loop
  spelling, not "you reimplemented a library function", which is the only thing
  LibraryBehaviorMatch can say. notes/todo.txt:1000 called this in advance.
• Sort is still not detected. The two blockers are the fixpoint loop
  (bubble-with-flag repeats on a flag, not a counter) and the early-stopping
  loop (insertion's while j > 0 && v[j-1] > v[j]). Neither is a normalization
  gap; both are genuinely different shapes.