feat(llvm): Phase 132-P0 - block_end_values tuple-key fix for cross-function isolation

## Problem
`block_end_values` used block ID only as key, causing collisions when
multiple functions share the same block IDs (e.g., bb0 in both
condition_fn and main).

## Root Cause
- condition_fn's bb0 → block_end_values[0]
- main's bb0 → block_end_values[0] (OVERWRITES!)
- PHI resolution gets wrong snapshot → dominance error

## Solution (Box-First principle)
Change key from `int` to `Tuple[str, int]` (func_name, block_id):

```python
# Before
block_end_values: Dict[int, Dict[int, ir.Value]]

# After
block_end_values: Dict[Tuple[str, int], Dict[int, ir.Value]]
```

## Files Modified (Python - 6 files)

1. `llvm_builder.py` - Type annotation update
2. `function_lower.py` - Pass func_name to lower_blocks
3. `block_lower.py` - Use tuple keys for snapshot save/load
4. `resolver.py` - Add func_name parameter to resolve_incoming
5. `wiring.py` - Thread func_name through PHI wiring
6. `phi_manager.py` - Debug traces

## Files Modified (Rust - cleanup)

- Removed deprecated `loop_to_join.rs` (297 lines deleted)
- Updated pattern lowerers for cleaner exit handling
- Added lifecycle management improvements

## Verification

- ✅ Pattern 1: VM RC: 3, LLVM Result: 3 (no regression)
- ⚠️ Case C: Still has dominance error (separate root cause)
  - Needs additional scope fixes (phi_manager, resolver caches)

## Design Principles

- **Box-First**: Each function is an isolated Box with scoped state
- **SSOT**: (func_name, block_id) uniquely identifies block snapshots
- **Fail-Fast**: No cross-function state contamination

## Known Issues (Phase 132-P1)

Other function-local state needs same treatment:
- phi_manager.predeclared
- resolver caches (i64_cache, ptr_cache, etc.)
- builder._jump_only_blocks

## Documentation

- docs/development/current/main/investigations/phase132-p0-case-c-root-cause.md
- docs/development/current/main/investigations/phase132-p0-tuple-key-implementation.md

🤖 Generated with [Claude Code](https://claude.com/claude-code)

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

src/llvm_py/builders/function_lower.py

@@ -49,6 +49,12 @@ def lower_function(builder, func_data: Dict[str, Any]):
         builder.bb_map.clear()
     except Exception:
         builder.bb_map = {}
+    # Phase 132-P0: Clear phi_manager per-function to avoid ValueId collisions
+    try:
+        if hasattr(builder, 'phi_manager') and hasattr(builder.phi_manager, 'predeclared'):
+            builder.phi_manager.predeclared.clear()
+    except Exception:
+        pass
     try:
         # Reset resolver caches keyed by block names
         builder.resolver.i64_cache.clear()
@@ -292,12 +298,14 @@ def lower_function(builder, func_data: Dict[str, Any]):
         loop_plan = None
 
     # Phase 131-4 Pass A: Lower non-terminator instructions (terminators deferred)
+    # Phase 132-P0: Pass func.name for tuple-key (func_name, block_id)
     from builders.block_lower import lower_blocks as _lower_blocks
-    _lower_blocks(builder, func, block_by_id, order, loop_plan)
+    _lower_blocks(builder, func, block_by_id, order, loop_plan, func_name=name)
 
     # Phase 131-14-B Pass B: Resolve jump-only block snapshots (BEFORE PHI finalization)
+    # Phase 132-P0: Pass func_name for tuple-key
     from builders.block_lower import resolve_jump_only_snapshots as _resolve_jump_only_snapshots
-    _resolve_jump_only_snapshots(builder, block_by_id)
+    _resolve_jump_only_snapshots(builder, block_by_id, func_name=name)
 
     # Optional: capture lowering ctx for downstream helpers
     try:
@@ -321,7 +329,8 @@ def lower_function(builder, func_data: Dict[str, Any]):
         pass
 
     # Phase 131-4 Pass B (now Pass B2): Finalize PHIs (wires incoming edges)
-    _finalize_phis(builder)
+    # Phase 132-P0: Pass func_name for tuple-key resolution
+    _finalize_phis(builder, func_name=name)
 
     # Phase 131-4 Pass C: Lower deferred terminators (after PHIs are placed)
     from builders.block_lower import lower_terminators as _lower_terminators