phase11: merge 33 + cookbook 125-126 — 554 bodies / 563 regions

Worker D's 0x8009F890 (248 B, first attempt) -- the THIRD member of a family it had already
matched twice, and the three were found by three different means: the size ranker, adjacency,
and the rebuilt global-redundancy rank. 'The finder varies, the price does not.' The
operational conclusion: families should be SEARCHED for explicitly rather than waited for.

126: worker D withdrew a named direction after checking its own notes and finding it had
already been tested and made the row worse. It declined a fifth spelling on a falsified lever
and corrected the row's record to the honest state. A direction that has been tested and
failed must be struck, or the next worker inherits a false lead.

config/regions.tsv

@@ -384,6 +384,7 @@
 0x8009F5AC	0x8009F6A0	src/func_8009F5AC.c
 0x8009F6A0	0x8009F798	src/func_8009F6A0.c
 0x8009F798	0x8009F890	src/func_8009F798.c
+0x8009F890	0x8009F988	src/func_8009F890.c
 0x800A2F20	0x800A2F44	src/func_800A2F20.c
 0x800A34E8	0x800A3540	src/func_800A34E8.c
 0x800A45E0	0x800A466C	src/func_8009E8D0.c

docs/MATCHING_COOKBOOK.md

@@ -2037,3 +2037,41 @@ with the global best rows and the confound is gone.
 
 **The general lesson: when work is divided among workers, any per-worker statistic is contaminated by
 the division.** Check the division before believing a cross-worker trend.
+
+### 125. "THE FINDER VARIES, THE PRICE DOES NOT" — and families should be SEARCHED for (worker D)
+
+Worker D matched the **third member of a family it had already matched twice**, and the three were
+found by **three different means**:
+
+| row | found by |
+|---|---|
+| `0x8009F6A0` | the **size** ranker (it was the smallest row above the ceiling) |
+| `0x8009F5AC` | **adjacency** (the row immediately before it) |
+| `0x8009F890` | the **rebuilt global-redundancy rank** (score 0.73) |
+
+All three are the same 3-short-row rotation — the third cyclic pairing of the negation pattern
+(`0x8009F6A0` negates rows 1+2, `0x8009F5AC` rows 0+1, `0x8009F890` rows 0+2), with the same
+`int t[3][4]` row-stride lever, the same 48-byte frame, and the same unused `0x0C`/`0x1C` slots.
+
+**Worker D's formulation is the right one: *the finder varies, the price does not.*** Once a lever is
+in hand, a member of the same family is a **one-attempt row wherever it sits.**
+
+**And the operational conclusion follows directly:** *"the family — and families like it — should be
+SEARCHED FOR explicitly rather than waited for."* Three rankers found three members of one family by
+accident. **Searching the worklist for a matched row's siblings is cheaper than waiting for a ranker
+to surface them.**
+
+### 126. Withdrawing a falsified direction (worker D, self-correction #4)
+
+Worker D offered a named direction for `0x80044D78` ("two pointer variables, a base and a cursor, for
+the first clear loop"), then **checked its own notes and withdrew it** — it had already tested that
+direction, and it made the row **worse**: 456 B for the indexed spelling, 448 for the base+cursor
+spelling, against 480. Four spellings spent, still 24–32 bytes short.
+
+**So it declined to spend a fifth on a lever it had already shown not to work**, and corrected the row's
+recorded state to the honest one: *"structure fully read off, 4 spellings spent, no working direction"*
+— **not** "cheap, direction in hand."
+
+**A direction that has been tested and failed must be struck from the row's record, or the next worker
+inherits a false lead.** That is the fourth self-correction from this worker and it is the one most
+likely to save someone else a session.