linq_fold: PR E R1 — gate Array pass on no-bridge (Copilot #1)

Pre-existing latent bug surfaced by the PR E refactor. peel_each only
unwraps `each(<array>)`, so `extract_decs_bridge(top)` still succeeds
on a from_decs eager-bridge source after the Decs pass. If the Decs
pass cascaded (e.g. emit_group_by's non-primitive join-key bail at
linq_fold.das:4475), the Array pass would re-match the same decs-only
row (decs_source predicate stays true) and emit_group_by would take
its Array branch — silently dropping the upstream_join capture and
mis-splicing the chain.

Same shape existed in master (plan_decs_group_by stub cascaded ->
plan_group_by stub re-matched group_by_decs row with Array adapter).
Never exercised by tests because no in-tree fixture combines
from_decs + non-primitive-key join + group_by, but the path was real.

Fix: in try_splice_patterns, return null after the Decs pass when
bridge != null. Cascaded decs chains now fall through to tier-2
fold_linq_default — the safety net that materializes the bridge buffer
and re-runs the chain — instead of risking a wrong-adapter emission.

doc/source/reference/linq_fold_patterns.rst "How dispatch works":
restated pass 2 as "runs only when bridge == null", with the WHY
inline (peel_each leaves the eager bridge intact, so without the gate
decs_source predicates would still match in the Array pass).

Verification: 1689/1689 tests/linq + 9809/9815 full suite (same
baseline). No test changed result, confirming nothing was relying on
the bug-path emission.

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

Author: borisbat

daslib/linq_fold.das

@@ -6487,6 +6487,8 @@ def private try_splice_patterns(var expr : Expression?) : Expression? {
             }
         }
     }
+    // Cascaded decs chains fall through to fold_linq_default rather than risk a decs-only row matching here (peel_each doesn't strip the eager-bridge ExprInvoke, so decs_source stays true) and emitting via Array adapter — see linq_fold_patterns.rst "How dispatch works".
+    if (bridge != null) return null
     top = peel_each(top)
     let srcName = qn("source", at)
     for (p in splice_patterns) {

doc/source/reference/linq_fold_patterns.rst

@@ -29,25 +29,28 @@ described below, and hands the result to ``try_splice_patterns`` in
 ``splice_patterns`` table (17 rows, one per arm listed in this
 document) twice:
 
-1. **Decs adapter pass.** Skipped unless
+1. **Decs adapter pass.** Runs only when
    ``extract_decs_bridge(top) != null`` (i.e. the source is
    ``from_decs_template(...)``). Each row's ``requires`` predicates
    gate the match; rows with an ``array_source`` predicate fail
    here and fall through. First emit that returns non-null wins.
-2. **Array adapter pass.** Runs with ``peel_each(top)``. Rows with
-   ``decs_source`` / ``decs_join_invariants`` predicates fail this
-   pass; the remaining rows match against the (now-peeled) top.
+2. **Array adapter pass.** Runs only when ``extract_decs_bridge(top)
+   == null``, i.e. the source is **not** a decs eager bridge. Top is
+   first ``peel_each``-unwrapped. Decs chains never reach this pass:
+   if the Decs pass above cascades on every row, control falls
+   through to ``fold_linq_default`` instead. (This is deliberate —
+   ``peel_each`` does not strip the eager-bridge ``ExprInvoke``, so
+   without this gate the ``decs_source`` predicate would still
+   succeed on a decs source in the Array pass and decs-only rows
+   could match and emit via ``SourceAdapter::Array``, silently
+   dropping adapter-specific captures like ``upstream_join``.)
 
 If neither pass emits, the Theme 6 perf-warn fires for
 ``from_decs_template`` chains (telling the user the bridge will
 materialize and tier-2 will run on the buffer), then control falls
 through to ``fold_linq_default`` (the iterator-materializing tier-2
 path) and finally to a raw passthrough.
 
-The "decs-first" rule is preserved at the dispatcher level rather
-than per-row, so a chain starting with ``from_decs_template(...)``
-always tries every decs-eligible arm before any array arm.
-
 .. note::
 
    Labels of the form ``plan_<X>`` (e.g. ``plan_distinct``,