perf(planning): prune candidates that cannot beat the protected prefix

Finalizing a candidate never moves or retypes a placement, so preference
results and calendar optimizations already have their final values before
it, and leave-balance optimizations do too when nothing can be earned.
Reject a candidate before finalizing when the first differing such
objective of the protected prefix is worse than the baseline. Leave-placement
objectives and earning contexts stop the walk.

The frozen-engine check now also compares cancelled asynchronous runs,
including checkpoints and retained incumbents. The loaded year drops from
48.5 s to 44.3 s; outcomes, explanations and final states are unchanged.

Refs #284

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

src/app/services/frozen-engine.spec.ts

@@ -3,11 +3,15 @@ import { createOptimizationPresetRules } from './rule-service';
 import { frenchPublicHolidaysForYear, isWorkingPlanningDate } from './declared-non-working-days';
 import { OPTIMIZATION_CATALOG } from './planning-objectives';
 import {
+	calculatePlanningAsyncInternal,
 	calculatePlanningInternal,
 	type PlanningArtifacts,
 	type PlanningOutcome,
 } from './leave-planner.core';
-import { calculatePlanningInternal as frozenCalculate } from './frozen-engine/leave-planner.core.frozen.mjs';
+import {
+	calculatePlanningAsyncInternal as frozenCalculateAsync,
+	calculatePlanningInternal as frozenCalculate,
+} from './frozen-engine/leave-planner.core.frozen.mjs';
 
 /** Rebuild instructions for the frozen engine: docs/benchmark/README.md. */
 const BASE_SEED = 280_000;
@@ -214,13 +218,67 @@ function assertSameAsFrozen(seed: number): void {
 	}
 }
 
+type AsyncEngine = typeof calculatePlanningAsyncInternal;
+
+/** Cancels after a seed-derived step count: during preparation, mid-search, or never. */
+function cancelAfter(seed: number, total: number): number {
+	const rnd = mulberry32(seed ^ 0x5bd1e995);
+	const roll = rnd();
+	if (roll < 0.1) return Math.floor(rnd() * total);
+	if (roll < 0.25) return Number.POSITIVE_INFINITY;
+	// Preparation is most of the steps; spend the rest of the budget on the search.
+	return Math.floor(total * (0.9 + rnd() * 0.1));
+}
+
+async function runCancelled(engine: AsyncEngine, request: Req, limit: number) {
+	const calls: unknown[] = [];
+	const artifacts: unknown[] = [];
+	const explanations: unknown[] = [];
+	const outcomes: unknown[] = [];
+	let polls = 0;
+	const outcome = await engine(
+		structuredClone(request),
+		(plan, state) => calls.push({ plan, state }),
+		({ timings: _timings, ...rest }) => artifacts.push(rest),
+		(o) => outcomes.push(o),
+		(...args) => explanations.push(args),
+		() => ++polls > limit,
+	);
+	return { outcome, calls, artifacts, explanations, outcomes, polls };
+}
+
+const cancelledKinds = new Map<string, number>();
+let incumbents = 0;
+
+async function assertCancelledSameAsFrozen(seed: number): Promise<void> {
+	const request = generateRequest(seed);
+	const total = (await runCancelled(calculatePlanningAsyncInternal, request, Infinity)).polls;
+	const limit = cancelAfter(seed, total);
+	const current = await runCancelled(calculatePlanningAsyncInternal, request, limit);
+	const frozen = await runCancelled(frozenCalculateAsync, request, limit);
+	const kind = current.outcome.kind;
+	cancelledKinds.set(kind, (cancelledKinds.get(kind) ?? 0) + 1);
+	if (kind === 'PlanningIncomplete' && current.calls.length) incumbents++;
+	try {
+		expect(current).toStrictEqual(frozen);
+	} catch (error) {
+		throw new Error(
+			`Cancelled run differs from frozen engine. seed=${seed} limit=${limit}\nrequest=${JSON.stringify(request)}\n${
+				(error as Error).message
+			}`,
+			{ cause: error },
+		);
+	}
+}
+
 const ONLY_SEED = process.env['FROZEN_ENGINE_SEED'];
 
 describe('frozen engine differential check', () => {
 	if (ONLY_SEED) {
-		it(`matches the frozen engine for seed ${ONLY_SEED}`, () => {
+		it(`matches the frozen engine for seed ${ONLY_SEED}`, async () => {
 			assertSameAsFrozen(Number(ONLY_SEED));
-		});
+			await assertCancelledSameAsFrozen(Number(ONLY_SEED));
+		}, 120_000);
 		return;
 	}
 	for (let from = 0; from < CASES; from += CHUNK) {
@@ -229,6 +287,19 @@ describe('frozen engine differential check', () => {
 		}, 120_000);
 	}
 
+	for (let from = 0; from < CASES; from += CHUNK * 2) {
+		it(`matches the frozen engine when cancelled, seeds ${BASE_SEED + from}.. every 10th`, async () => {
+			for (let i = from; i < from + CHUNK * 2; i += 10)
+				await assertCancelledSameAsFrozen(BASE_SEED + i);
+		}, 300_000);
+	}
+
+	it('retains incumbents of cancelled calculations', () => {
+		console.info('cancelled coverage', Object.fromEntries(cancelledKinds), { incumbents });
+		expect(cancelledKinds.get('PlanningIncomplete') ?? 0).toBeGreaterThan(20);
+		expect(incumbents).toBeGreaterThan(10);
+	});
+
 	afterAll(() => {
 		console.info(
 			'frozen-engine coverage of generated cases',