Recognize an all-different check, and say what replacing it costs

[zmaril]

Stacked on #41.

Recognizes a hand-rolled all-different check and recommends
itertools::Itertools::all_unique, with the conditions under which that swap is
sound.

Why this needs a recognizer rather than a derived behavior

No library checks distinctness by comparing every pair. all_unique reaches the
answer through a hash set, so derivation produces a hash-set form and the
quadratic loop it exists to replace matches nothing. The shape has to be named
directly — the way the strum recognizers name a shape a derive macro would have
produced, but over the normalized form rather than the syntax tree, which is
what lets one recognizer cover spellings that share no syntax.

It is matched by the same unification everything else goes through. Bindings
already works out what every hole stood for and used to discard it at the door;
Form::resolve_all hands it back as Resolved, so the conditions are stated
about the pieces the matcher found rather than ones a second traversal went
looking for. Evidence, span placement and target naming come from the shared
helpers.

Conditions

A match says the code computes what the API computes. It does not say the two
are interchangeable, and here they are not:

• reaching the answer through a hash set needs Eq + Hash where the loop needs
  only PartialEq — not pedantry, since f64 is PartialEq and not Eq, and
  two NaNs are unequal to each other, so the loop calls them distinct and the
  set cannot be built at all
• it allocates where the loop does not
• it need not run the comparison at all where the loop runs it quadratically
• at four elements the loop wins

The bound is read off the catalog, not written from memory. The same signature
gates the match: the callable must still take a receiver and still return
bool, per AGENTS.md's rule that a matcher verify what it relies on.

Measured

11 findings across 127,210 CodeNet Rust files, every one read by hand and
confirmed. Zero across 3,650 files of production Rust, where the idiom is
written with a HashSet already.

The first run found zero, and the corpus corrected the shape twice — the bound
(pairwise loops are bound by a bare variable six to one over len()) and the
reaction (println!("no"); return; and ans = false, not return false).

Recall was then checked against a labelled set: CodeNet groups submissions by
problem, so a problem that is about distinctness labels its submissions for
free. Of 330 submissions to three such problems, 18 hand-roll a nested loop and
11 are found. The 7 misses each have a reason, listed in the commit messages.

continue is the commonest thing a pairwise equality test does — six times more
common than every accepted spelling combined — and it is skipping duplicate
pairs inside a larger computation. It is refused, and so is count += 1.

Review notes

• 322 tests, clippy clean.
• Coverage on Pairwise has two inhabitants and both are measured; a walk over
  adjacent pairs is deliberately NOT one of them here (it arrives in Catalog the standard library, and recognize a sortedness check #43).
• Idiom is compiled in rather than pack data. Now that the shape is a Form
  it is nearly authorable as data; what blocks it is the predicate on the holes,
  which would need alternation and negative conditions in the pattern language.