Detect value-independent branches: const-fold, splat-follow, is_leaf_sig

[ChrisRackauckas-Claude]

Please ignore until reviewed by @ChrisRackauckas. Draft opened by an agent.

Summary

hasbranching reports false positives (and, behind splat forwarders, false negatives) on real SciML/MTK ODE right-hand sides — a purely linear ẋ = x − a·x comes back true, needlessly disabling ReverseDiff tape compilation in SciMLSensitivity. Three value-independent constructs were mis-scored; this PR teaches the scan to ignore them, with one general mechanism per case and no per-container overrides.

1. Compile-time-constant branches are skipped

A GotoIfNot whose condition inference proves Core.Const (an x isa T test on a concretely-typed field — the ODEFunction functor's if f.f isa AbstractSciMLOperator — or the device/type-introspection dispatch inside ML library layers, #46) can never be taken differently under a tracing AD. A literal true/false condition written directly in source is not skipped — that stays a genuine branch.

2. Branches behind splatted calls are followed

g(args...) lowers to Core._apply_iterate(iter, g, groups...), burying the real callee as an argument of a Core builtin, so the old scan dead-ended at the forwarder. That's the SciML/MTK RHS shape (ODEFunction → GeneratedFunctionWrapper → RuntimeGeneratedFunction → generated_callfunc), so a registered relu behind it was missed. The scan now follows the apply.

3. Branches a constant argument decides are refuted

Ordinary recursion widens arguments to types, so a branch selecting a buffer by a literal index (split-mode MTK getindex(::MTKParameters, ::Int)) looks value-dependent even though every real call site folds it. The type recursion stays the source of truth. Only when it reports a branch inside a call carrying Core.Const arguments does the callee get re-inferred with those constants preserved (no optimizer, so no library/structural branches are inlined into view); if that folds the branch, the finding is refuted.

This is a strict refinement: it can only downgrade a reported branch to branch-free, never the reverse. So it never introduces a false positive on arbitrary code — verified against broadcast and ComponentArray-based neural-network RHS, which an earlier "run const-prop everywhere" approach broke (const inference propagates a constant into getproperty(::ComponentArray, ::Symbol)'s specialized path and surfaces an unfolded index branch). Refuting only found branches sidesteps that entirely.

Version robustness (lts / 1 / pre)

The constant refutation uses Base.Compiler/Core.Compiler internals whose API differs across versions (the InferenceState construction and inferred-source location already differ between 1.12 and 1.13). It is functionally gated: a probe runs a constant-decided-branch fixture through the const inference at first use and only activates the refutation if the fold actually works; otherwise the analysis is exactly the plain type recursion. Any inference failure is caught and leaves the branch reported (conservative).

Verified by running the suite on each channel:

channel	version	refutation	tests
lts	1.10.11	gated off	✓
1	1.12.6	active	✓
pre	1.13.0-rc1	active	✓

End to end

The MTK RHS table through the ODEFunction (linear/power branch-free, relu branchy, both split modes) is correct with no container-specific overrides — the constant refutation handles the split-mode MTKParameters case generically. (Requires the companion unwrap so hasbranching looks through the SciMLFunction wrapper: SciML/SciMLBase.jl#1413.)

Tests

Existing tests pass unchanged; added regression tests for each mechanism (const isa skipped while real inner branch kept; splat-forwarded branch detected; constant-index branch refuted where the compiler cooperates, genuine and dynamic-index branches always kept). Runic clean.

Semver

Additive / false-positive fix, non-breaking: 0.1.6 → 0.1.7.