feat(loop-phi): Add body-local variable PHI generation for Rust AST loops

Phase 25.1c/k: Fix ValueId undefined errors in loops with body-local variables

**Problem:**
- FuncScannerBox.scan_all_boxes/1 and BreakFinderBox._find_loops/2 had ValueId
  undefined errors for variables declared inside loop bodies
- LoopFormBuilder only generated PHIs for preheader variables, missing body-locals
- Example: `local ch = s.substring(i, i+1)` inside loop → undefined on next iteration

**Solution:**
1. **Rust AST path** (src/mir/loop_builder.rs):
   - Detect body-local variables by comparing body_end_vars vs current_vars
   - Generate empty PHI nodes at loop header for body-local variables
   - Seal PHIs with latch + continue snapshot inputs after seal_phis()
   - Added HAKO_LOOP_PHI_TRACE=1 logging for debugging

2. **JSON v0 path** (already fixed in previous session):
   - src/runner/json_v0_bridge/lowering/loop_.rs handles body-locals
   - Uses same strategy but for JSON v0 bridge lowering

**Results:**
- ✅ FuncScannerBox.scan_all_boxes: 41 body-local PHIs generated
- ✅ Main.main (demo harness): 23 body-local PHIs generated
- ⚠️ Still some ValueId undefined errors remaining (exit PHI issue)

**Files changed:**
- src/mir/loop_builder.rs: body-local PHI generation logic
- lang/src/compiler/entry/func_scanner.hako: debug logging
- /tmp/stageb_funcscan_demo.hako: test harness

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

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

src/mir/loop_builder.rs

@@ -340,18 +340,124 @@ impl<'a> LoopBuilder<'a> {
         self.set_current_block(latch_id)?;
 
         // Update variable map with body end values for sealing
-        for (name, value) in body_end_vars {
-            self.update_variable(name, value);
+        for (name, value) in &body_end_vars {
+            self.update_variable(name.clone(), *value);
         }
 
         self.emit_jump(header_id)?;
         // 📦 Hotfix 6: Add CFG predecessor for header from latch (same as legacy version)
         crate::mir::builder::loops::add_predecessor(self.parent_builder, header_id, latch_id)?;
 
+        // Phase 25.1c/k: body-local 変数の PHI 生成
+        // BreakFinderBox / FuncScannerBox 等で、loop body 内で新規宣言された local 変数が
+        // loop header に戻った時に undefined になる問題を修正
+        let trace_loop_phi = std::env::var("HAKO_LOOP_PHI_TRACE").ok().as_deref() == Some("1");
+        if trace_loop_phi {
+            eprintln!("[loop-phi/body-local] Checking for body-local variables");
+            eprintln!("  current_vars.len()={}, body_end_vars.len()={}", current_vars.len(), body_end_vars.len());
+        }
+
+        // Detect body-local variables (variables declared in body, not in preheader)
+        let body_local_vars: Vec<(String, ValueId)> = body_end_vars
+            .iter()
+            .filter(|(name, _value)| !current_vars.contains_key(name.as_str()))
+            .map(|(name, value)| (name.clone(), *value))
+            .collect();
+
+        if !body_local_vars.is_empty() {
+            if trace_loop_phi {
+                eprintln!("[loop-phi/body-local] Found {} body-local variables", body_local_vars.len());
+            }
+
+            // Add PHI nodes for body-local variables at header
+            for (var_name, _latch_value) in &body_local_vars {
+                if trace_loop_phi {
+                    eprintln!("[loop-phi/body-local] Adding PHI for body-local var: {}", var_name);
+                }
+
+                let phi_id = self.new_value();
+
+                // Insert empty PHI at header (will be sealed by seal_phis or later)
+                if let Some(ref mut func) = self.parent_builder.current_function {
+                    if let Some(header_block) = func.blocks.get_mut(&header_id) {
+                        // Find position after existing PHIs
+                        let phi_count = header_block.phi_instructions().count();
+                        header_block.instructions.insert(
+                            phi_count,
+                            MirInstruction::Phi {
+                                dst: phi_id,
+                                inputs: vec![],  // Empty PHI, will be filled by seal_phis
+                            },
+                        );
+                    }
+                }
+
+                // Rebind variable to PHI
+                self.update_variable(var_name.clone(), phi_id);
+            }
+
+            if trace_loop_phi {
+                eprintln!("[loop-phi/body-local] Added {} body-local PHIs", body_local_vars.len());
+            }
+        }
+
         // Pass 4: Seal PHIs with latch + continue values
         let continue_snaps = self.continue_snapshots.clone();
         loopform.seal_phis(self, actual_latch_id, &continue_snaps)?;
 
+        // Phase 25.1c/k: seal body-local PHIs (complete the inputs)
+        if !body_local_vars.is_empty() {
+            if trace_loop_phi {
+                eprintln!("[loop-phi/body-local] Sealing {} body-local PHIs", body_local_vars.len());
+            }
+
+            for (var_name, _) in &body_local_vars {
+                // Get the PHI we created earlier from current variable map
+                let current_map = self.get_current_variable_map();
+                let phi_id = current_map.get(var_name).copied()
+                    .ok_or_else(|| format!("Body-local variable '{}' not found in variable map", var_name))?;
+
+                // Build inputs: no preheader input (variable doesn't exist there),
+                // add latch input and continue inputs
+                let mut inputs: Vec<(BasicBlockId, ValueId)> = vec![];
+
+                // Add latch input
+                let latch_value = self.get_variable_at_block(var_name, actual_latch_id)
+                    .unwrap_or(phi_id);  // Fallback to phi_id if not found
+                inputs.push((actual_latch_id, latch_value));
+
+                // Add continue inputs
+                for (cid, snapshot) in &continue_snaps {
+                    if let Some(&value) = snapshot.get(var_name) {
+                        inputs.push((*cid, value));
+                    }
+                }
+
+                // Update PHI inputs
+                if let Some(ref mut func) = self.parent_builder.current_function {
+                    if let Some(header_block) = func.blocks.get_mut(&header_id) {
+                        // Find the PHI instruction for this variable
+                        for instr in &mut header_block.instructions {
+                            if let MirInstruction::Phi { dst, inputs: phi_inputs } = instr {
+                                if *dst == phi_id {
+                                    *phi_inputs = inputs.clone();
+                                    if trace_loop_phi {
+                                        eprintln!("[loop-phi/body-local] Sealed '{}' phi={:?} inputs={:?}",
+                                            var_name, phi_id, inputs);
+                                    }
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            if trace_loop_phi {
+                eprintln!("[loop-phi/body-local] Sealed {} body-local PHIs", body_local_vars.len());
+            }
+        }
+
         // Exit block
         self.set_current_block(exit_id)?;