feat(asm): rewrite built-in macros with parameterized opcodes and @ret wiring

- #reduce_add_N replaced with #reduce_N op (parameterized opcode via ${op})
- #loop_counted gains @ret_body/@ret_exit markers with pass fanout node
to avoid 3-edge constraint on brgt compare node
- #loop_while gains @ret_body/@ret_exit markers
- Tests updated for new macro names and invocation syntax

asm/builtins.py

···
 These macros are automatically available in all dfasm programs.
 The BUILTIN_MACROS string is prepended to user source before parsing.
 
-Macro parameters can appear in edge endpoints via ${param} syntax.
-The expand pass handles parameter refs in source/dest positions,
-correctly skipping scope qualification for external references.
+Macro parameters can appear in edge endpoints via ${param} syntax,
+in opcode position via ${op}, and in qualifier positions via |${pe}
+and :${port}. The expand pass resolves all ParamRef placeholders.
 
-The opcode position cannot be parameterized (grammar constraint:
-opcode is a keyword terminal). Per-opcode variants are provided
-where needed (e.g., reduce_add_N).
+Macros use @ret/@ret_name markers for output wiring via the |> syntax
+at call sites.
 """
 
 BUILTIN_MACROS = """\
···
 ; These macros are automatically available in all dfasm programs.
 
 ; --- Counted loop ---
-; Expands to: &counter (add), &compare (brgt), &inc (inc)
-; Internal wiring: counter -> compare:L, compare -> inc:L, inc -> counter:R
-; User wires: init -> counter:L, limit -> compare:R, compare -> body:L, compare -> exit:R
+; Topology: counter -> compare -> body_fan (fanout) -> inc -> feedback
+;           compare L -> body_fan (pass as fanout) -> @ret_body + &inc
+;           compare R -> @ret_exit
+; User wires: init -> counter:L, limit -> compare:R
+; Call with: #loop_counted |> body=&process, exit=&done
 #loop_counted |> {
     &counter <| add
     &compare <| brgt
     &counter |> &compare:L
+    &body_fan <| pass
+    &compare |> &body_fan:L
     &inc <| inc
-    &compare |> &inc:L
+    &body_fan |> &inc:L
     &inc |> &counter:R
+    &body_fan |> @ret_body
+    &compare |> @ret_exit:R
 }
 
 ; --- Condition-tested loop ---
-; Expands to: &gate (gate)
-; User wires: test_node -> gate:L, gate -> body:L, gate -> exit:R
+; Topology: &gate (gate) -> L=body, R=exit
+; User wires: test_value -> gate:L
+; Call with: #loop_while |> body=&process, exit=&done
 #loop_while |> {
     &gate <| gate
+    &gate |> @ret_body
+    &gate |> @ret_exit:R
 }
 
 ; --- Permit injection (per-arity variants) ---
···
     &p3 |> &merge_b:R
 }
 
-; --- Binary reduction trees (per-arity, per-opcode variants) ---
-; Note: The opcode position cannot be parameterized (grammar constraint).
-; Per-opcode variants are provided instead.
-#reduce_add_2 |> {
-    &r <| add
+; --- Binary reduction trees (parameterized opcode) ---
+; Usage: #reduce_2 add, #reduce_3 sub, etc.
+#reduce_2 op |> {
+    &r <| ${op}
 }
 
-#reduce_add_3 |> {
-    &r0 <| add
-    &r1 <| add
+#reduce_3 op |> {
+    &r0 <| ${op}
+    &r1 <| ${op}
     &r0 |> &r1:L
 }
 
-#reduce_add_4 |> {
-    &r0 <| add
-    &r1 <| add
-    &r2 <| add
+#reduce_4 op |> {
+    &r0 <| ${op}
+    &r1 <| ${op}
+    &r2 <| ${op}
     &r0 |> &r2:L
     &r1 |> &r2:R
 }

tests/test_builtins.py

···
 
         assert "#loop_counted" in BUILTIN_MACROS
         assert "#permit_inject_1" in BUILTIN_MACROS
-        assert "#reduce_add_2" in BUILTIN_MACROS
+        assert "#reduce_2 op" in BUILTIN_MACROS
 
     def test_builtins_prepended_to_pipeline(self):
         """Verify that built-in macros are prepended in run_pipeline."""
···
         """Built-in macro is used when user doesn't define it."""
         source = """
         @system pe=1, sm=0
-        #reduce_add_2
+        #reduce_2 add
         """
         graph = run_pipeline(source)
         assert graph is not None
···
 
         node_names = list(graph.nodes.keys())
         has_r = any("&r" in n for n in node_names)
-        assert has_r, f"Expected &r node from #reduce_add_2 expansion in {node_names}"
+        assert has_r, f"Expected &r node from #reduce_2 expansion in {node_names}"
 
 
 class TestAC83_LoopCountedTopology:
···
         """
         source = """
         @system pe=1, sm=0
-        #loop_counted
+        &body <| pass
+        &exit <| pass
+        #loop_counted |> body=&body, exit=&exit
         """
         graph = run_pipeline(source)
         assert len(graph.errors) == 0
···
         """
         source = """
         @system pe=1, sm=0
-        #loop_counted
+        &body <| pass
+        &exit <| pass
+        #loop_counted |> body=&body, exit=&exit
         """
         graph = run_pipeline(source)
 
···
 class TestAC84_EndToEnd:
     """AC8.4: Program using built-in macros assembles and runs in emulator."""
 
-    def test_builtin_reduce_add_2_invoked_assembles(self):
-        """#reduce_add_2 invocation assembles through the full pipeline."""
+    def test_builtin_reduce_2_invoked_assembles(self):
+        """#reduce_2 add invocation assembles through the full pipeline."""
         source = """
         @system pe=1, sm=0
-        #reduce_add_2
+        #reduce_2 add
         """
         result = assemble(source)
         assert result is not None, "assemble() should succeed"
         assert len(result.pe_configs) > 0, "Should have PE configs"
 
-    def test_builtin_reduce_add_2_runs_in_emulator(self):
-        """#reduce_add_2 runs through emulator without error."""
+    def test_builtin_reduce_2_runs_in_emulator(self):
+        """#reduce_2 add runs through emulator without error."""
         source = """
         @system pe=1, sm=0
-        #reduce_add_2
+        #reduce_2 add
         """
         outputs = run_program_direct(source, until=500)
         assert 0 in outputs, "PE 0 should exist in outputs"
 
-    def test_builtin_reduce_add_2_produces_output_when_wired(self):
-        """#reduce_add_2 produces correct sum when inputs and output are wired."""
+    def test_builtin_reduce_2_produces_output_when_wired(self):
+        """#reduce_2 add produces correct sum when inputs and output are wired."""
         source = """
         @system pe=1, sm=0
         &a <| const, 3
         &b <| const, 4
         &out <| pass
-        #reduce_add_2
-        &a |> #reduce_add_2_0.&r:L
-        &b |> #reduce_add_2_0.&r:R
-        #reduce_add_2_0.&r |> &out:L
+        #reduce_2 add
+        &a |> #reduce_2_0.&r:L
+        &b |> #reduce_2_0.&r:R
+        #reduce_2_0.&r |> &out:L
         """
         outputs = run_program_direct(source, until=500)
         all_values = []
···
         outputs = run_program_direct(source, until=500)
         assert 0 in outputs, "PE 0 should exist in outputs"
 
-    def test_builtin_reduce_add_3_assembles(self):
-        """#reduce_add_3 invocation assembles through the full pipeline."""
+    def test_builtin_reduce_3_assembles(self):
+        """#reduce_3 add invocation assembles through the full pipeline."""
         source = """
         @system pe=1, sm=0
-        #reduce_add_3
+        #reduce_3 add
         """
         result = assemble(source)
         assert result is not None, "assemble() should succeed"
         assert len(result.pe_configs) > 0, "Should have PE configs"
 
-    def test_builtin_reduce_add_3_runs_in_emulator(self):
-        """#reduce_add_3 runs through emulator without error."""
+    def test_builtin_reduce_3_runs_in_emulator(self):
+        """#reduce_3 add runs through emulator without error."""
         source = """
         @system pe=1, sm=0
-        #reduce_add_3
+        #reduce_3 add
         """
         outputs = run_program_direct(source, until=500)
         assert 0 in outputs, "PE 0 should exist in outputs"
···
             assert macro_name in BUILTIN_MACROS, \
                 f"Expected {macro_name} definition in BUILTIN_MACROS"
 
-    def test_reduce_add_variants_defined_in_builtins(self):
-        """All #reduce_add_2 through #reduce_add_4 are defined."""
+    def test_reduce_variants_defined_in_builtins(self):
+        """All #reduce_2 through #reduce_4 are defined with op parameter."""
         from asm.builtins import BUILTIN_MACROS
 
         for i in range(2, 5):
-            macro_name = f"#reduce_add_{i}"
-            assert macro_name in BUILTIN_MACROS, \
-                f"Expected {macro_name} definition in BUILTIN_MACROS"
+            macro_name = f"#reduce_{i}"
+            assert f"{macro_name} op" in BUILTIN_MACROS, \
+                f"Expected '{macro_name} op' definition in BUILTIN_MACROS"
 
-            start = BUILTIN_MACROS.find(macro_name)
-            end = BUILTIN_MACROS.find("#", start + 1)
+            start = BUILTIN_MACROS.find(f"{macro_name} op")
+            end = BUILTIN_MACROS.find("\n#", start + 1)
             if end == -1:
                 end = len(BUILTIN_MACROS)
             macro_body = BUILTIN_MACROS[start:end]
 
-            assert "add" in macro_body, \
-                f"{macro_name} should use 'add' opcode for reduction"
+            assert "${op}" in macro_body, \
+                f"{macro_name} should use '${{op}}' parameter for opcode"
 
 
 class TestBuiltinComposition: