Make the out-of-place jacobian's return type inferrable

[ChrisRackauckas-Claude]

Please ignore until reviewed by @ChrisRackauckas.

Closes SciML/NonlinearSolve.jl#1092

Problem

The out-of-place finite_difference_jacobian infers to Any:

julia> g(x) = x .^ 2 .- 2
julia> x = [1.0, 2.0, 3.0];
julia> cache = FiniteDiff.JacobianCache(x, Val{:forward}, eltype(x));
julia> Base.return_types(FiniteDiff.finite_difference_jacobian, typeof.((g, x, cache)))
1-element Vector{Any}:
 Any

The calculate_Ji_forward / calculate_Ji_central / calculate_Ji_complex closures assign
variables that also exist in the enclosing function's scope (epsilon, vecfx, x_save,
dx, ...). An inner function assigning a name that exists in the enclosing scope binds the
outer variable, so those became captured variables with several assignment sites — which
closure conversion boxes. Reading a boxed capture gives Any, and that propagates through
mapreduce(calculate_Ji_*, hcat, ...) to the returned matrix. rows_index / cols_index
had the same problem via the comprehension that reassigns them.

@report_opt on the FiniteDiff path, before:

captured variable `epsilon` detected
captured variable `vecfx` detected
captured variable `rows_index` detected
captured variable `cols_index` detected
runtime dispatch detected: op::typeof(hcat)(%69::Any, %70::Any)::Any

Fix

Declare the closures' temporaries local so they stop aliasing the enclosing function's
variables, rename the few that had to stay distinct from a genuine capture, and give
vecfx / rows_index / cols_index a single assignment site each.

No behavioral change — the closures only ever wrote those outer variables incidentally, and
no branch read the values back afterwards.

After:

julia> Base.return_types(FiniteDiff.finite_difference_jacobian, typeof.((g, x, cache)))
1-element Vector{Any}:
 Matrix{Float64}

Static-array inputs stay uninferrable, which is a separate (and harder) problem: the hcat
accumulator gains one SMatrix column per color, so its type depends on the runtime value
of maximum(colorvec). Noted in a comment next to the new test.

Downstream motivation

This is the root cause of SciML/NonlinearSolve.jl#1092 — the
Jacobian cache is typed by this return value, so the whole solver cache inferred to an open
where-bound:

using NonlinearSolve, ADTypes, SciMLBase
prob = NonlinearProblem((u, p) -> u .^ 2 .- 2.0, [1.0])
@inferred SciMLBase.init(prob, TrustRegion(autodiff = AutoFiniteDiff()))   # ERROR before, OK after

Testing

Added an inference regression test to test/out_of_place_tests.jl covering all three
fdtypes. Ran the full GROUP=Core suite locally on Julia 1.10.11 — green:

Test Summary:    | Pass  Total  Time
Public API Tests |   15     15  0.2s
Test Summary:             | Pass  Broken  Total   Time
FiniteDiff Standard Tests |  219       1    220  35.6s
Test Summary:               | Pass  Total     Time
Color Differentiation Tests |   39     39  4m12.5s
Test Summary:      | Pass  Total   Time
Out of Place Tests |   28     28  40.1s
Test Summary:            | Pass  Total  Time
Cache Reuse Safety Tests |   27     27  4.5s

(the one Broken is pre-existing)

🤖 Generated with Claude Code

https://claude.ai/code/session_01MoeiVWqAEFJQK22kiXu48f

[ChrisRackauckas-Claude]

CI: test (Core, 1) is green. test (Downstream, 1) is red, but it is pre-existing on master — the last three master CI runs (29184179777, 29184168199, 29184127467) all show the same Downstream failure with Core passing.

The failure is unrelated to this diff:

LoadError: ArgumentError: array of type LinearAlgebra.Tridiagonal{Float64, Vector{Float64}} and size (10, 10)
  can not be filled with 1.0, since some of its entries are constrained.
  [1] fill! @ .../stdlib/v1.12/LinearAlgebra/src/special.jl:358 [inlined]
  [2] build_J_W(...) @ OrdinaryDiffEqDifferentiation .../src/derivative_utils.jl:1231

fill! on a structured matrix inside OrdinaryDiffEq's Rosenbrock alg_cache, nothing to do with finite_difference_jacobian.