Fix GPU InvalidIR: compute _col_major_offset via unrolled_reduce [perf]

The real cause of the persisting Integrals/matrix GPU InvalidIRError
(ijl_get_nth_field_checked in single_column_reduce!/bycolumn_kernel! and
eager_copyto_stencil_kernel!) was F1's `_col_major_offset` helper, written as a
tuple TAIL-RECURSION. It constant-folds on CPU, but under the deep inlining of a
stencil / column-reduce kernel, device inference exhausts its recursion/const-prop
budget, widens the peeled tuple argument to an abstract `Tuple`, and lowers
`idx[1]` to a runtime bounds-checked `getfield` (ijl_get_nth_field_checked) that
cannot compile on device. (The earlier type-level flat_mode change was not the
culprit; it is kept as harmless hardening.)

Replace the recursion with `unrolled_reduce` (UnrolledUtilities, already a
DataLayouts dependency), keeping all unrolling isolated to that package rather
than an ad-hoc @generated: it emits a non-self-recursive unrolled body that folds
regardless of the surrounding inference budget. Carries (offset, stride) in a
left fold over the (size, coord) pairs.

Verified locally (device-free GPUCompiler IR check, manual CompilerJob on the
real device kernel types — not the Adapt path): bycolumn_kernel! (extruded +
column) and eager_copyto_stencil_kernel! now compile clean; DataLayouts
unit_loops / unit_struct / unit_fill_and_copyto pass; CPU getindex/setindex
values unchanged.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: dennisYatunin

src/DataLayouts/indexing.jl

@@ -142,11 +142,23 @@ end
 end
 
 # Column-major linear offset (0-based) of coordinate tuple `idx` in an array of
-# static size `sz`. Tail recursion over tuples inlines to a folded Horner form;
-# `sz` entries are type-domain literals, only the coordinates are runtime values.
-@inline _col_major_offset(::Tuple{}, ::Tuple{}) = 0
-@inline _col_major_offset(sz::Tuple, idx::Tuple) =
-    (idx[1] - 1) + sz[1] * _col_major_offset(Base.tail(sz), Base.tail(idx))
+# static size `sz`, computed with `unrolled_reduce` so all unrolling lives in
+# UnrolledUtilities. A tuple tail-recursion folds on CPU but, under the deep
+# inlining of a stencil/column-reduce kernel, GPU inference hits its
+# recursion/const-prop budget, widens the peeled tuple to an abstract `Tuple`,
+# and lowers `idx[1]` to a runtime bounds-checked `getfield`
+# (`ijl_get_nth_field_checked`) that cannot compile on device. `unrolled_reduce`
+# emits a non-self-recursive unrolled body that folds regardless of the
+# surrounding inference budget. It carries `(offset, stride)`: at axis `k` the
+# offset gains `(idx[k] - 1) * stride` and the stride advances by `sz[k]`.
+@inline _col_major_offset(sz::Tuple, idx::Tuple) = first(
+    unrolled_reduce(
+        unrolled_map(tuple, sz, idx);
+        init = (0, 1),
+    ) do (offset, stride), (s, i)
+        (offset + (i - 1) * stride, stride * s)
+    end,
+)
 
 @inline _first_n(t::Tuple, ::Val{n}) where {n} = ntuple(k -> t[k], Val(n))