Emit drops basis_change on one product-rule term for a repeated (aliased) diff leaf — ∂(FᵀF)/∂F half-wrong #112

Summary

When emitting the tangent diff(expr, X) where the leaf X appears more than
once (e.g. C = XᵀX via inner_product(X,{1},X,{1})), numsim-codegen lowers
one of the two product-rule terms to tmech without its basis_change index
permutation, so the emitted rank-4 is in the wrong index layout and the tangent
comes out wrong (exactly half for d(FᵀF)/dF).

The numsim-cas symbolic tree is correct — cas's own tensor_evaluator
evaluates the same diff(FᵀF, F) to the exact two-term result (err 1.1e-16 vs
dFᵀF + FᵀdF). The defect is purely in the codegen emit/lowering of that tree.
Was briefly mis-filed as numsim-cas#331 (now retracted/closed).

Reproduction

Recipe: input F (declare non-symmetric — roles::Other — so dF/dF is the
full identity), output C = inner_product(F, sequence{1}, F, sequence{1}),
add_algorithmic_tangent("dC_dF", "C", "F"). Emitted body:

auto t0 = inner_product<seq<1>,seq<1>>(F, F);                 // C = FᵀF
auto t1 = otimesu(eye, eye);
auto t2 = inner_product<seq<1>,seq<1>>(F, t1);               // term A — NO basis_change
auto t3 = otimesu(eye, eye);
auto t4 = inner_product<seq<1>,seq<1>>(t3, F);
auto t5 = basis_change<seq<1,3,4,2>>(t4);                    // term B — has basis_change
auto t6 = t2 + t5;
dC_dF_out = t6;

Contracting each term with an arbitrary dF and comparing to the analytic
dFᵀF / FᵀdF:

t5 : dF  ==  dFᵀF                       (exact — term B correct)
t2 : dF  ==  neither dFᵀF nor FᵀdF      (err 9.75e-1 to both — term A wrong layout)

So t2 should carry a basis_change (it is FᵀdF in the wrong slot order) and
doesn't. (t2+t5):dF is off by 9.75e-1 → the whole tangent is wrong.

Contrast — distinct leaves are fine: G = AᵀB, diff(G, A) emits a single
term with its basis_change and FD-matches to 7e-11. The bug is specific to
the repeated/aliased leaf, where the product rule yields two terms and one of
them loses its permutation during emit.

Where to look

The tensor code-emit index-permutation logic (code_emit/tensor_code_emit.h /
the inner_product + basis_change lowering). It looks like the permutation for
one product-rule term is computed as identity (and thus skipped) when it should
be non-identity. Compare the two summands' index sequences coming out of
cas::diff and ensure each summand's basis_change is emitted.

Impact

Blocks correct finite-strain tangents ∂stress/∂F where C = FᵀF (or b=FFᵀ).
∂stress/∂C (single symmetric leaf) is unaffected and FD-verified. Same
silent-wrong-tangent risk class as the FD spine (#90) exists to catch —
recommend an FD golden with an aliased-leaf kinematic map once fixed.