feat(footnote): absorb one-line footnote widows by bumping reserve (SD-2656)

Adds a `runWidowOrphanAbsorb` pass between the convergence loop and the
preferred-reserve scorer. For every page whose predicted footnote tail
is one line short (≤ 24 px), bumps the reserve to the page's preferred
value, bypassing the scorer's page-count-growth gate.

The scorer's gate exists to prevent global regressions when a trial
trades local fidelity for added pages. For one-line widows the trade
is bounded — Word's pagination always absorbs them. The implementation
reuses the existing buildFootnoteLedgers, applyReserves, growReserves,
and capReserveForRelayout helpers; the only new logic is the threshold
filter and the unconditional bump.

## Threshold rationale

Threshold = 24 px (one line of footnote text plus slack). Measurements
on the Carlsbad fixture: at threshold = 35 px the absorb pass creates
new cluster splits on pages 25-29; at threshold = 24 px no regression
is measurable. 24 is the largest value with a clean profile across the
two test fixtures.

## Trade-off

This pass may grow the document to absorb widows. On the IRA fixture,
six one-line widows bump cleanly but force the doc 45 → 48 pages. The
"revert on grow" guard would make the pass a no-op everywhere unless a
doc has body slack (test fixtures do not). The trade is accepted for
docs whose layouts genuinely have nowhere to absorb a widow without
growth. Future work pairs this with body paragraph widow/orphan
controls so the body absorbs the pushed line for free.

## Verified

- layout-bridge 1281, layout-engine 657, layout-tests 332 — all green.
- Carlsbad: unchanged at 46p / 3 splits (no one-line tails to absorb).
- IRA: 45p / 17 splits → 48p / 9 splits (8 widows absorbed, 3 page cost).

Author: tupizz

packages/layout-engine/layout-bridge/src/incrementalLayout.ts

@@ -2615,6 +2615,37 @@ export async function incrementalLayout(
           }
         }
 
+        // Absorb one-line footnote widows by bumping their reserve to
+        // preferred. The scorer would reject this as a page-count regression;
+        // for one-line tails the cost is bounded and Word's pagination always
+        // absorbs them.
+        const ONE_LINE_TAIL_PX = 24;
+        const runWidowOrphanAbsorb = async () => {
+          const ledgers = buildFootnoteLedgers(finalPlan, reservesAppliedToLayout, layout.pages.length);
+          const target = reservesAppliedToLayout.slice();
+          let bumped = 0;
+          for (const ledger of ledgers) {
+            const tailPx = ledger.continuationOut.reduce((s, e) => s + (e.remainingHeightPx || 0), 0);
+            if (tailPx <= 0 || tailPx > ONE_LINE_TAIL_PX) continue;
+            const requested = capReserveForRelayout(
+              ledger.preferredReservePx,
+              ledger.pageIndex,
+              layout,
+              reservesAppliedToLayout,
+            );
+            if (requested > (target[ledger.pageIndex] ?? 0)) {
+              target[ledger.pageIndex] = requested;
+              bumped += 1;
+            }
+          }
+          if (bumped === 0) return;
+          const safeApplied = reservesAppliedToLayout.slice();
+          await applyReserves(target);
+          if (!(await growReserves(GROW_MAX_PASSES))) {
+            await applyReserves(safeApplied);
+          }
+        };
+        await runWidowOrphanAbsorb();
         await runPreferredReserveTrials();
 
         const blockById = new Map<string, FlowBlock>();