fix: function call routing — input trampolines use INHERIT, assign act_ids to function body nodes

Two root causes for the last 3 test failures:

1. Input trampoline edges incorrectly used ctx_override=True, which caused
CHANGE_TAG mode. CHANGE_TAG unpacks the left operand as a packed FrameDest,
but input trampolines receive raw data values — not FrameDests. Changed
input edges to use normal routing (INHERIT mode reads dest from frame slot,
which already encodes the function's act_id).

2. Function body nodes (e.g. $adder.&a, $adder.&sum) got act_id=0 (root
scope) instead of the call site's act_id. When a function has call sites,
its body nodes must share the call site's activation context so FrameDest
routing targets the correct frame.

Also fixed test_builtins.py and test_variadic.py to inject setup_tokens
before seed_tokens (matching test_e2e.py's pattern).

asm/allocate.py

···
     updated_nodes = {}
 
     # Build global mapping of which nodes belong to which call sites
+    # Trampoline and free_frame nodes get the call site's act_id
     callsite_for_node = {}  # node_name -> CallSite
     for call_site in call_sites:
         for tramp_node in call_site.trampoline_nodes:
             callsite_for_node[tramp_node] = call_site
         for free_node in call_site.free_frame_nodes:
             callsite_for_node[free_node] = call_site
+
+    # Build mapping: function scope -> call site (for function body nodes)
+    func_scope_to_callsite = {}  # func_name -> CallSite
+    for call_site in call_sites:
+        func_scope_to_callsite[call_site.func_name] = call_site
 
     # Allocate activation IDs for this PE
     next_act_id = 0
···
             call_site = callsite_for_node[node.name]
             act_id_value = call_site_to_act_id_on_pe.get(call_site)
 
-        # If not part of a call site, use function scope or root scope
+        # If not part of a call site, check if it's a function body node
         if act_id_value is None:
             scope = _extract_function_scope(node.name)
-            act_id_value = scope_to_act_id.get(scope, root_act_id)
+            if scope in func_scope_to_callsite:
+                # Function body node — gets the call site's act_id
+                cs = func_scope_to_callsite[scope]
+                act_id_value = call_site_to_act_id_on_pe.get(cs)
+            if act_id_value is None:
+                act_id_value = scope_to_act_id.get(scope, root_act_id)
 
         updated_nodes[node.name] = replace(node, act_id=act_id_value)
 

asm/expand.py

···
             )
             wired_edges.append(source_to_tramp)
 
-            # Wire: trampoline -> target (with ctx_override)
+            # Wire: trampoline -> target (no ctx_override — INHERIT mode reads
+            # the destination FrameDest from the frame, which already encodes
+            # the function's act_id. CHANGE_TAG is wrong here because the left
+            # operand is raw data, not a packed FrameDest.)
             tramp_to_target = IREdge(
                 source=tramp_name,
                 dest=target_label,
                 port=Port.L,
-                ctx_override=True,
                 loc=call_site.loc,
             )
             wired_edges.append(tramp_to_target)
         else:
-            # No conflict — direct edge with ctx_override
+            # No conflict — direct edge (no ctx_override — the destination
+            # node's act_id in the FrameDest handles cross-context routing)
             input_edge = IREdge(
                 source=source_name,
                 dest=target_label,
                 port=Port.L,
-                ctx_override=True,
                 loc=call_site.loc,
             )
             wired_edges.append(input_edge)

tests/test_builtins.py

···
     env = simpy.Environment()
     sys = build_topology(env, result.pe_configs, result.sm_configs)
 
-    # Inject seed tokens
+    # Inject setup tokens first (frame/IRAM initialization)
+    for setup in result.setup_tokens:
+        sys.inject(setup)
+
+    # Then inject seed tokens
     for seed in result.seed_tokens:
         sys.inject(seed)
 

tests/test_call_wiring.py

···
     assert len(call_site.free_frame_nodes) > 0
 
 
-def test_input_edges_have_ctx_override():
-    """Input edges from call site to function parameters have ctx_override=True.
+def test_input_edges_use_inherit_not_ctx_override():
+    """Input edges from call site to function parameters use INHERIT, not CHANGE_TAG.
 
-    When source node has a const, a pass trampoline is inserted to avoid
-    the const+CTX_OVRD conflict (AC5.3). The ctx_override edge is then
-    from the trampoline to the function parameter.
+    In the frame-based model, cross-context routing for input edges is handled by
+    the FrameDest's act_id (which differs between caller and function activation).
+    Only return trampolines use ctx_override/CHANGE_TAG because they decode a
+    packed FrameDest from EXTRACT_TAG.
     """
     source = """
     $add |> {
···
     graph = parse_lower_expand(source)
 
     # Since &x has const=5, a trampoline is inserted: &x -> trampoline -> $add.&a
-    # The ctx_override edge is from the trampoline to $add.&a
-    ctx_override_to_a = False
+    # Neither edge should have ctx_override — input routing uses INHERIT mode
     for edge in graph.edges:
-        if "$add.&a" in str(edge.dest) and edge.ctx_override:
-            ctx_override_to_a = True
-            break
+        if "$add.&a" in str(edge.dest):
+            assert not edge.ctx_override, (
+                f"Input edge to $add.&a should NOT have ctx_override "
+                f"(frame-based routing uses INHERIT with act_id in FrameDest)"
+            )
 
-    assert ctx_override_to_a, (
-        f"Expected ctx_override edge targeting $add.&a, "
-        f"edges: {[(e.source, e.dest, e.ctx_override) for e in graph.edges]}"
-    )
+    # Only return trampoline edges should have ctx_override
+    ret_ctx_override = [e for e in graph.edges if e.ctx_override]
+    assert len(ret_ctx_override) > 0, "Return trampoline should have ctx_override"
+    for e in ret_ctx_override:
+        assert "__ret_trampoline" in e.source, (
+            f"Only return trampolines should have ctx_override, got: {e.source} -> {e.dest}"
+        )
 
 
 def test_shared_function_body():

tests/test_variadic.py

···
 
         env = simpy.Environment()
         sys = build_topology(env, result.pe_configs, result.sm_configs)
+        for setup in result.setup_tokens:
+            sys.inject(setup)
         for seed in result.seed_tokens:
             sys.inject(seed)
         env.run(until=500)