Preserve finite element pullbacks when collecting monomials

[pbrubeck]

The TSFC side of the FIAT stack firedrakeproject/fiat#282 -> #284 -> #281.
One PR, because the two commits below are what make that stack observable at
all: the GEM changes are inert unless TSFC passes the argument indices.

What changes

• Cost linear map preservation against expansion (tsfc/spectral.py).
  A pullback reaches TSFC as a sum over one argument axis. Expanding it exposes
  scalar factorisation across its entries; preserving it exposes a tabulation
  that several argument axes share. Neither dominates, so flatten builds both
  plans and keeps the cheaper by estimate_cost, skipping the second
  factorisation when has_linear_maps says there is no map to preserve.

  This replaces a len(free_indices) > 1 heuristic. The heuristic was not
  merely inelegant: on a CG degree 3 Laplacian in 2D, preserving the map costs
  8,305 operations against 8,125 for expanding it, so preservation has to be
  rejected on cost, which counting argument axes cannot do.

• Tabulate adjacent shared maps in one loop (tsfc/loopy.py).
  One preserved map per ComponentTensor gave one loop each, so a single fused
  nest became three loops over the same extent. Reusing one iname per bound
  index fuses them back.

  The iname is reused only between adjacent tabulations. Sharing it whenever
  the index matches breaks 13 tests with pytools.graph.CycleError: impero
  interleaves other statements between tabulations that depend on them, and one
  iname cannot be both inside and outside the statement between. statement_block
  therefore resets the memo on any statement that is not a ComponentTensor
Evaluate. Scoping by loop depth instead is not enough, as the cycle recurs
  one level down.

Effect

Raviart--Thomas is where the pullback is worth preserving. On
inner(u, v)*dx + inner(curl(u), curl(v))*dx, main to this PR:

family	dim	degree	flops main	flops PR	AST lines main	AST lines PR
RT	2	3	23,318	18,038	90	81
RT	2	5	253,051	192,564	90	81
RT	3	3	374,589	255,933	136	109
RT	3	5	12,965,694	8,711,463	136	109

Arithmetic falls 32% at degree 3 and 33% at degree 5 in 3D, with 31% fewer
scalar temporaries and 20% fewer lines of C. Q and NCE are untouched: on a
tensor-product cell no sum depends on exactly one argument index, so the second
plan is never built. The full 18-case table is in firedrakeproject/fiat#284.

On time this reaches parity, not a speedup. Best of four interleaved
repetitions:

case	main (s)	PR (s)	change	main -fno-fast-math	PR	change
RT3 3D	0.014052	0.013975	-0.5%	0.015036	0.013638	-9.3%
RT5 3D	0.068845	0.068857	+0.0%	0.075158	0.068414	-9.0%

PyOP2 compiles with -ffast-math, so gcc may reassociate a*x + a*y into
a*(x + y) and hoist the sum out of the loop, which is exactly the saving
preservation makes structurally. Forbid the reassociation and the two separate:
main loses 7.0% and 9.2% while this branch loses 2.4% and 0.6%. The counted
32-33% is real, and the C compiler was already collecting most of it. What
remains is a third fewer operations to schedule and a representation that does
not depend on gcc choosing to reassociate.

Before the loop fusion the branch was 7-11% slower on these cases, so that
commit is load-bearing rather than a tidy-up.

Validation

• tests/tsfc and the zany helmholtz, interpolate and projection regression
  suites (437 passed)
• test_impero_loopy_flop_counts.py covers the ComponentTensor case that
  count_flops previously turned into a silent zero;
  test_sum_factorisation.py covers the plan selection.

Notes

A DROP BEFORE MERGE commit adds a step to .github/actions/install/action.yml
that installs the head of that FIAT stack over the one pyproject.toml resolves
from main, so CI exercises both halves together. Revert it once they land.

AI assistance

Claude Code was used for implementation, benchmarking, and drafting this
section. The human contributor remains responsible for understanding,
validating, and maintaining the changes.