feat(emit): implement Behavior::Loop emission for Python and Go

[briansrls]

Summary

• Behavior::Loop is emitted in Python and Go by rendering the body DAG's result port, which preserves recursive self-calls natively supported by both targets
• Documents the IR invariant at each emit site: Loop has exactly two construction sites in lower.rs, both for recursive user functions (Cardinality and Descent bounds); collection folds go through callable realizations and never reach Loop
• Adds port() / node() substrate accessor helpers to the Python roundtrip test prelude (the std.substrate host functions used by unused_parameters.dag when walking DAG edges)
• Removes #[ignore] from three tests that were blocked on Loop emission

Why body-port rendering is correct semantics

Behavior::Loop wraps a recursive function whose body DAG already contains the recursive self-calls. In both the Cardinality (single recursion, lower.rs ~3631) and Descent (mutual recursion cluster, lower.rs ~382) cases, loop_node.body is the root node of the function body DAG — the same DAG the compiler proved terminates. Rendering the body node's result port preserves those recursive calls. Python and Go handle recursion natively; the source/init/bound fields encode the termination proof, not operational iteration state.

Each emit site documents the IR invariant and flags what must be updated if Loop is ever extended to non-recursive collection iteration.

Test plan

• emit_python_module_marks_ownership_as_skipped_for_gc_target — passes
• emitted_python_lens_matches_emitted_rust_lens_on_reflected_programs — passes (Rust and Python produce identical unused-parameter sets)
• emit_go_lens_unused_parameters_module — passes
• Full cargo test -p v3-compiler --test integration — running

🤖 Generated with Claude Code

[briansrls]

Review note:

This is materially different from #677 in the right way: I checked lower.rs, and Behavior::Loop really is only constructed at the two recursive-function sites (src/v3/compiler/src/lower.rs:382 and :3631). That makes the core semantic argument much stronger than the earlier rejected shortcut. It also matches the existing Rust emitter behavior, which already renders Loop by delegating to the body node’s result port.

One thing I’d still like before treating this as a durable closure: add a direct Python/Go receipt for a plain recursive user function program, not just the unused_parameters.dag lens path. Right now the un-ignored tests prove the reflected-lens case, but the contract being claimed is broader: recursive user functions lower through Behavior::Loop and emit correctly on Python/Go.

A small targeted roundtrip using something like recursive_function_call_six (or an even smaller source-local recursive fn fixture) would pin that claim directly and make the lane harder to regress later.

[briansrls]

Review metadata

• Provider / model: claude / claude-opus-4-7
• Commit: 724c9d0f · Trigger: schedule
• Thinking: 108s wall

---

Findings

None blocking. A couple of small observations:

• src/v3/compiler/src/emit.rs:1255 and src/v3/compiler/src/emit/python_target.rs:1041 — the safety of "render body's result port" depends on the invariant that Behavior::Loop only wraps recursive user functions today. I verified both construction sites in lower.rs (lines 382, 3631) and they match the comment. The Rust target already does the same thing (emit/rust_target.rs:4325), so this PR is just bringing Python/Go into parity. The dissolution trigger ("if a future IR change adds Loop for non-recursive collection iteration") is documented and bounded — qualifies as tracked debt.

• src/v3/compiler/tests/boundary/m1_4_emit_python_test.rs:339-345 — the new node accessor uses n._0.id. Fine for an in-test reflected-Dag prelude, but it's coupled to the variant tuple-field naming convention emitted for Behavior. Not a violation; just brittle if that convention shifts. Implementation-layer concern.

Verdict

APPROVE. The change reverses the over-eager fail-closed guard from 0089c00 for a justified reason: lower.rs only emits Behavior::Loop for recursive function bodies, the body DAG already carries the recursive self-calls, and Python/Go handle recursion natively — exactly mirroring the existing Rust target. Comments capture the construction-site invariant and name a concrete dissolution trigger, so this is a tracked bridge rather than silent collapse. Re-enabling the three previously-ignored lens tests is appropriate.

[briansrls]

Review metadata

• Provider / model: codex / gpt-5.4
• Commit: 724c9d0f · Trigger: schedule
• Thinking: 391s wall

---

Verdict: APPROVE. I don’t see a concrete violation of INVARIANTS.md, docs/modeling-discipline.md, CODING.md, or TESTING.md in the touched lines. The new Go/Python Behavior::Loop handling is consistent with the existing Rust emitter’s treatment of recursive loops, and the accompanying test changes are aligned with the boundary-level coverage this PR is exercising.