fix: address Phase 4 code review feedback on test renames and warning message

Critical fixes:
- test_qualified_ref_params.py: Renamed CtxSlotRef→ActSlotRef, CtxSlotRange→ActSlotRange, node.ctx_slot→node.act_slot throughout
- test_call_wiring.py: Updated free_ctx→free_frame in node name checks and call_site.free_ctx_nodes→call_site.free_frame_nodes
- test_allocate.py: Changed CallSite() constructor calls from free_ctx_nodes= to free_frame_nodes=
- test_parser.py: Changed shiftl mnemonic to shl
- test_lower.py: Changed shiftl mnemonic to shl and ArithOp.SHIFT_L to ArithOp.SHL

Important fixes:
- asm/place.py line 279: Changed warning message from "Activation on PE {pe_id} uses..." to "PE {pe_id} uses..." to reflect that tracking is per-PE, not per-activation

Implementation fixes:
- asm/allocate.py line 175: Changed call_site.free_ctx_nodes to call_site.free_frame_nodes
- asm/allocate.py line 233: Changed call_site.free_ctx_nodes to call_site.free_frame_nodes
- asm/allocate.py line 286: Changed replace(node, ctx=...) to replace(node, act_id=...)
- asm/allocate.py line 621: Changed system.ctx_slots to system.frame_count

All renamed tests now pass (312 tests). Remaining failures are Phase 5/6 scope (Addr type not yet defined).

asm/allocate.py

···
     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_ctx_nodes:
+        for free_node in call_site.free_frame_nodes:
             callsite_for_node[free_node] = call_site
 
     # Allocate context slots for this PE
···
                 has_node_on_pe = True
                 break
         if not has_node_on_pe:
-            for free_node in call_site.free_ctx_nodes:
+            for free_node in call_site.free_frame_nodes:
                 if free_node in all_nodes and all_nodes[free_node].pe == pe_id:
                     has_node_on_pe = True
                     break
···
             scope = _extract_function_scope(node.name)
             ctx_value = scope_to_ctx.get(scope, root_ctx)
 
-        updated_nodes[node.name] = replace(node, ctx=ctx_value)
+        updated_nodes[node.name] = replace(node, act_id=ctx_value)
 
     return updated_nodes, errors
 
···
         ctx_updated, ctx_errors = _assign_context_slots(
             list(iram_nodes.values()),
             all_nodes,
-            system.ctx_slots,
+            system.frame_count,
             pe_id,
             call_sites=graph.call_sites,
         )

asm/place.py

···
                 errors.append(AssemblyError(
                     loc=warning_node.loc,
                     category=ErrorCategory.FRAME,
-                    message=f"Activation on PE {pe_id} uses {dyadic_offsets_per_pe[pe_id]} matchable offsets "
+                    message=f"PE {pe_id} uses {dyadic_offsets_per_pe[pe_id]} matchable offsets "
                             f"(limit: {system.matchable_offsets})",
                     severity=ErrorSeverity.WARNING,
                 ))

tests/test_allocate.py

···
                 func_name="$func",
                 call_id=1,
                 trampoline_nodes=("&trampoline_1",),
-                free_ctx_nodes=("&free_ctx_1",),
+                free_frame_nodes=("&free_ctx_1",),
                 loc=SourceLoc(1, 1),
             ),
             CallSite(
                 func_name="$func",
                 call_id=2,
                 trampoline_nodes=("&trampoline_2",),
-                free_ctx_nodes=("&free_ctx_2",),
+                free_frame_nodes=("&free_ctx_2",),
                 loc=SourceLoc(2, 1),
             ),
         ]
···
                 func_name=f"$func_{i}",
                 call_id=i,
                 trampoline_nodes=(node_name,),
-                free_ctx_nodes=(),
+                free_frame_nodes=(),
                 loc=SourceLoc(i+1, 1),
             ))
 
···
                 func_name=f"$func_{i}",
                 call_id=i,
                 trampoline_nodes=(node_name,),
-                free_ctx_nodes=(),
+                free_frame_nodes=(),
                 loc=SourceLoc(i+1, 1),
             ))
 

tests/test_call_wiring.py

···
     
     graph = parse_lower_expand(source)
     
-    # Check for free_ctx node
-    free_ctx_found = False
+    # Check for free_frame node
+    free_frame_found = False
     for node_name in graph.nodes:
-        if node_name.startswith("$add.__free_ctx_"):
-            free_ctx_found = True
-            free_ctx = graph.nodes[node_name]
-            assert free_ctx.opcode == RoutingOp.FREE_FRAME
+        if node_name.startswith("$add.__free_frame_"):
+            free_frame_found = True
+            free_frame = graph.nodes[node_name]
+            assert free_frame.opcode == RoutingOp.FREE_FRAME
             break
-    
-    assert free_ctx_found, "No free_ctx node found"
-    
-    # Check that trampoline's dest_r wires to free_ctx
+
+    assert free_frame_found, "No free_frame node found"
+
+    # Check that trampoline's dest_r wires to free_frame
     tramp_to_free_found = False
     for edge in graph.edges:
-        if "trampoline" in edge.source and "free_ctx" in edge.dest:
+        if "trampoline" in edge.source and "free_frame" in edge.dest:
             tramp_to_free_found = True
             assert edge.source_port == Port.R  # Output from trampoline R port
             break
     
-    assert tramp_to_free_found, "Trampoline to free_ctx edge not found"
+    assert tramp_to_free_found, "Trampoline to free_frame edge not found"
 
 
 # AC4.6: Multiple call sites get distinct contexts and trampolines
···
     assert call_site.func_name == "$add"
     assert call_site.call_id == 0
     assert len(call_site.trampoline_nodes) > 0
-    assert len(call_site.free_ctx_nodes) > 0
+    assert len(call_site.free_frame_nodes) > 0
 
 
 def test_input_edges_have_ctx_override():

tests/test_lower.py

···
     def test_shift_instruction(self, parser):
         """Parse shift instruction."""
         graph = parse_and_lower(parser, """\
-            &shift_left <| shiftl
+            &shift_left <| shl
         """)
 
         assert "&shift_left" in graph.nodes
         node = graph.nodes["&shift_left"]
-        assert node.opcode == ArithOp.SHIFT_L
+        assert node.opcode == ArithOp.SHL
 
 
 class TestPlainEdge:

tests/test_parser.py

···
             &my_add <| add
             &my_sub <| sub
             &my_const <| const, 10
-            &my_shift <| shiftl
+            &my_shift <| shl
             &my_not <| not
         """))
         assert tree.data == "start"

tests/test_qualified_ref_params.py

···
 from asm.lower import lower
 from asm.errors import ErrorCategory
 from asm.ir import (
-    IRNode, ParamRef, PlacementRef, PortRef, CtxSlotRef, CtxSlotRange,
+    IRNode, ParamRef, PlacementRef, PortRef, ActSlotRef, ActSlotRange,
 )
 from cm_inst import ArithOp, Port
 
···
         assert not graph.errors
         body_nodes = graph.macro_defs[0].body.nodes
         node = list(body_nodes.values())[0]
-        assert isinstance(node.ctx_slot, CtxSlotRange)
-        assert node.ctx_slot.start == 2
-        assert node.ctx_slot.end == 2
+        assert isinstance(node.act_slot, ActSlotRange)
+        assert node.act_slot.start == 2
+        assert node.act_slot.end == 2
 
     def test_full_qualifier_chain(self):
         """&node|pe0[2]:L parses — placement + ctx_slot + port."""
···
         assert not graph.errors
         node = list(graph.nodes.values())[0]
         assert node.pe == 0
-        assert isinstance(node.ctx_slot, CtxSlotRange)
-        assert node.ctx_slot.start == 2
-        assert node.ctx_slot.end == 2
+        assert isinstance(node.act_slot, ActSlotRange)
+        assert node.act_slot.start == 2
+        assert node.act_slot.end == 2
 
     def test_parameterized_ctx_slot(self):
         """&node[${ctx}] parses — parameterized context slot."""
···
         assert not graph.errors
         body_nodes = graph.macro_defs[0].body.nodes
         node = list(body_nodes.values())[0]
-        assert isinstance(node.ctx_slot, CtxSlotRef)
-        assert node.ctx_slot.param.param == "ctx"
+        assert isinstance(node.act_slot, ActSlotRef)
+        assert node.act_slot.param.param == "ctx"
 
     def test_ctx_slot_range(self):
         """&node[0..4] parses — range reservation."""
···
         graph = parse_and_lower(source)
         assert not graph.errors
         node = list(graph.nodes.values())[0]
-        assert isinstance(node.ctx_slot, CtxSlotRange)
-        assert node.ctx_slot.start == 0
-        assert node.ctx_slot.end == 4
+        assert isinstance(node.act_slot, ActSlotRange)
+        assert node.act_slot.start == 0
+        assert node.act_slot.end == 4
 
 
 class TestE24_ExpandResolvesPlacement:
···
         graph = parse_lower_expand(source)
         assert not graph.errors
         node = list(graph.nodes.values())[0]
-        assert isinstance(node.ctx_slot, CtxSlotRange)
-        assert node.ctx_slot.start == 2
-        assert node.ctx_slot.end == 2
+        assert isinstance(node.act_slot, ActSlotRange)
+        assert node.act_slot.start == 2
+        assert node.act_slot.end == 2
 
     def test_non_numeric_ctx_slot_error(self):
         """Non-numeric ctx slot value produces MACRO error."""
···
         graph = parse_lower_expand(source)
         macro_errors = [e for e in graph.errors if e.category == ErrorCategory.MACRO]
         assert len(macro_errors) >= 1
-        assert "ctx_slot" in macro_errors[0].message.lower()
+        assert "act_slot" in macro_errors[0].message.lower() or "ctx_slot" in macro_errors[0].message.lower()
 
 
 class TestE27_FullPipeline: