Thirty-five arms become thirty: Power is data (#746)

[Rafael-SOWNet]

The largest switch in the transformation layer, and the one carrying the most
conditions. Patterns.PowerRules has thirty-five arms; five separate issues — #752,
#801, #802, #902 and #721 — each put a branch-cut guard on one rewrite in it. As data
it is thirty rules.

The guards are asked, not restated. MayTakeLogOfPower, MayGatherLogarithms and
ReduceRadical stay in Patterns.Power.cs and the rules call them. Copying a branch-cut
condition into a second file is how the two copies come to disagree, and one of these has
already been wrong in both directions at once (log(-3, -3) is 1 where a written-out
a > 0 calls it undefined; log(1, 1) is NaN where that guard calls it 1).

Two rules read what a Bindings cannot carry. log_b(b) = 1 takes the overload
handed the matched node, so the condition it attaches is the node's own DomainCondition.
The radical reduction asks ReduceRadical in both its when and its replacement, because
whether it applies and what it produces are one computation.

Six arms become two commutative patterns — a power times its own base, and a power
times a product containing its base. They fire exactly where the pair and the quadruple
did, since the switch writes every orientation out; firesWhereTheSwitchDoesNot is empty.

What this PR cost, and what it produced

The kernel gate failed the first version of this branch on allocation — SolveHard
+4.4%, SolveMediumHard +5.0%, past its 3% band. Not time, and not noise: allocation
reproduces to 0.033%.

The cause was the two commutative patterns. A commutative pattern is not
IsDeterministic, so TryApply enumerated its two candidates through an iterator state
machine per pattern node, at every node of every pass. My own pre-push measurement had
looked at Simplify, whose allocation is identical to the byte on every build here — so
the regression was invisible to it. The gate measures eighteen entry points because one of
them is not the others.

Writing the six arms out as node patterns fixed it, at the cost of the collapse. That was
a bad trade for a rule set language, so it became #1079 → #1080: a bounded pattern is
now walked by index rather than enumerated. With that in, the commutative form is the cheap
one:

	SolveMediumHard, allocated
master (2c082da4)	163,425,360 B
this branch, two commutative rules	164,959,936 B — +0.94%
the same, before #1080	171,367,976 B — +3.8%, gate red

SimplifyEasy is 129,648 B on both, to the byte.

What the differential run caught. Two arms bind their operands as Number, so 1 - c
folds to a literal in the switch where Entity arithmetic builds a Minusf. Both
disagreed on the first run of PowerAsDataMatchesTheSwitch over 3,464 generated
expressions, and neither is a case anyone would have written down by hand.

One test made stronger. EveryDataRuleIsClassifiedAsWritten now asserts that a rule
name never stands for two classifications. Power and Factorization deliberately carry
the same guarded a^b * c^b; without the assertion, a name meaning two things would have
listed the rule twice rather than failed.

Part of #746 tier 1.

🤖 Generated with Claude Code

https://claude.ai/code/session_01Bjumi5K7fg8yx6UK1mZTQd