Simplify registers a candidate once, and costs a subtree once: SimplifyHard -44% allocation

[Rafael-SOWNet]

Speed, measured where allocation is deterministic. Two changes, each answer-identical by
construction, found by attributing SimplifyHard's 3.62 GB per call to the steps of
Simplificator.Alternate with a temporary hook on AddHistory (not committed).

What was found

step of one level (976 MB)	bytes
AddHistory itself — candidate registration	862 MB
res.Expand().Simplify(-level)	316 MB
rule-based factorisation at level 2	305 MB
openedAngles.Expand().Simplify(-level)	149 MB
every rewrite pass together	< 30 MB

AddHistory registered every candidate twice: once as it was, once as
expr.Rewrite(InvertNegativePowers) — each registration a CanonicalOrder rewrite (the Sort
rules: 1.6 MB and 1 ms on the 473-node input alone), an inner simplification and two ratings. On
an input with nothing to invert the second tree is the first tree, so the second registration
re-sorted an identical tree, rated it again, and offered the history set an entity it already held.

What changes

1. The second registration runs only where the inversion produced a different tree. Same
   candidates reach the set — a HashSet<Entity> already deduplicated the repeat — so the
   selection cannot move.
2. CostModel.DefaultCost costs a subtree once. It recursed through itself and scanned
   divisor.Nodes for every quotient; it now recurses through Entity.DefaultCostCached (the slot
   SimplifiedRate already fills on its unset path) and walks children by index. Same expression,
   same order, same doubles.

Measured

By the inter-version benchmark, on the machine the 1930th column was taken on this morning —
and the solvers move too, because Solve simplifies inside:

	1930th (this morning)	this change	allocation	time
SimplifyHard	3,662,375,240	2,027,771,744	−44.6%	1.60 s → 0.92 s
SolveHard	1,452,700,104	1,057,996,016	−27.2%	879 → 772 ms
SolveMediumHard	165,611,184	126,162,152	−23.8%	88 → 78 ms
SimplifyEasy	128,460	115,763	−9.9%	110 → 89 µs

Every other row is unchanged or inside its floor. Timings are one run against one run on one
machine and carry the performance file's usual rider; the allocation is the evidence. The cost
cache alone is −1.15% / −1.3% on the two Simplify rows; the registration change is the rest.
The gate's baseline is updated in the same change — its own document names a drop as the one case
where a red gate means nothing is wrong — and the gate passes on it.

Where the rest goes, for next time

After this a SimplifyHard level is: the remaining registration 431 MB; res.Expand().Simplify(-level)
177 MB; the level-2 rule-based factorisation 170 MB; the opened angles expanded 82 MB — each a
recursive simplification of an expanded tree, and each a change to what is offered rather than to
how, so not this PR.

Part of #746.

Checks

Full suite 9610 passed, 0 failed, 14 skipped — every pinned Simplify answer and the corpus gate unchanged.

🤖 Generated with Claude Code

https://claude.ai/code/session_012sonx8iAspMiwRwokT1Ura