🚀 Break/Continue/Try-Catch構文のサポート追加とMIRループ制御強化

## 主な変更点

### 🎯 MIRループ制御の実装（根治対応）
- src/mir/loop_builder.rs: Break/Continue対応のループコンテキスト管理
  - ループのbreak/continueターゲットブロック追跡
  - ネストループの適切な処理
- src/mir/builder.rs: Break/Continue文のMIR生成実装
- src/tokenizer.rs: Break/Continue/Tryトークン認識追加

### 📝 セルフホストパーサーの拡張
- apps/selfhost-compiler/boxes/parser_box.nyash:
  - Stage-3: break/continue構文受理（no-op実装）
  - Stage-3: try-catch-finally構文受理（構文解析のみ）
  - エラー処理構文の将来対応準備

### 📚 ドキュメント更新
- 論文K（爆速事件簿）: 45事例に更新（4件追加）
  - PyVM迂回路の混乱事件
  - Break/Continue無限ループ事件
  - EXE-first戦略の再発見
- 論文I（開発秘話）: Day 38の重要決定追加

### 🧪 テストケース追加
- apps/tests/: ループ制御とPHIのテストケース
  - nested_loop_inner_break_isolated.nyash
  - nested_loop_inner_continue_isolated.nyash
  - loop_phi_one_sided.nyash
  - shortcircuit関連テスト

## 技術的詳細
- Break/ContinueをMIRレベルで適切に処理
- 無限ループ問題（CPU 99.9%暴走）の根本解決
- 将来の例外処理機能への準備

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

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

src/mir/loop_builder.rs

@@ -67,6 +67,9 @@ impl<'a> LoopBuilder<'a> {
         let after_loop_id = self.new_block();
         self.loop_header = Some(header_id);
         self.continue_snapshots.clear();
+        self.parent_builder.loop_exit_stack.push(after_loop_id);
+        // Push loop context to parent builder (for nested break/continue lowering)
+        self.parent_builder.loop_header_stack.push(header_id);
         
         // 2. Preheader -> Header へのジャンプ
         self.emit_jump(header_id)?;
@@ -115,11 +118,15 @@ impl<'a> LoopBuilder<'a> {
         
         // 10. ループ後の処理
         self.set_current_block(after_loop_id)?;
-        
+        // Pop loop context
+        let _ = self.parent_builder.loop_header_stack.pop();
+        // loop exit stack mirrors header stack; maintain symmetry
+        let _ = self.parent_builder.loop_exit_stack.pop();
+
         // void値を返す
         let void_dst = self.new_value();
         self.emit_const(void_dst, ConstValue::Void)?;
-        
+
         Ok(void_dst)
     }
     
@@ -313,6 +320,88 @@ impl<'a> LoopBuilder<'a> {
     
     fn build_statement(&mut self, stmt: ASTNode) -> Result<ValueId, String> {
         match stmt {
+            ASTNode::If { condition, then_body, else_body, .. } => {
+                // Lower a simple if inside loop, ensuring continue/break inside branches are handled
+                let cond_val = self.parent_builder.build_expression(*condition.clone())?;
+                let then_bb = self.new_block();
+                let else_bb = self.new_block();
+                let merge_bb = self.new_block();
+                self.emit_branch(cond_val, then_bb, else_bb)?;
+
+                // then
+                self.set_current_block(then_bb)?;
+                for s in then_body.iter().cloned() {
+                    let _ = self.build_statement(s)?;
+                    // Stop if block terminated
+                    let cur_id = self.current_block()?;
+                    let terminated = {
+                        if let Some(ref fun_ro) = self.parent_builder.current_function {
+                            if let Some(bb) = fun_ro.get_block(cur_id) { bb.is_terminated() } else { false }
+                        } else { false }
+                    };
+                    if terminated { break; }
+                }
+                // Only jump to merge if not already terminated (e.g., continue/break)
+                {
+                    let cur_id = self.current_block()?;
+                    let need_jump = {
+                        if let Some(ref fun_ro) = self.parent_builder.current_function {
+                            if let Some(bb) = fun_ro.get_block(cur_id) { !bb.is_terminated() } else { false }
+                        } else { false }
+                    };
+                    if need_jump { self.emit_jump(merge_bb)?; }
+                }
+
+                // else
+                self.set_current_block(else_bb)?;
+                if let Some(es) = else_body {
+                    for s in es.into_iter() {
+                        let _ = self.build_statement(s)?;
+                        let cur_id = self.current_block()?;
+                        let terminated = {
+                            if let Some(ref fun_ro) = self.parent_builder.current_function {
+                                if let Some(bb) = fun_ro.get_block(cur_id) { bb.is_terminated() } else { false }
+                            } else { false }
+                        };
+                        if terminated { break; }
+                    }
+                }
+                {
+                    let cur_id = self.current_block()?;
+                    let need_jump = {
+                        if let Some(ref fun_ro) = self.parent_builder.current_function {
+                            if let Some(bb) = fun_ro.get_block(cur_id) { !bb.is_terminated() } else { false }
+                        } else { false }
+                    };
+                    if need_jump { self.emit_jump(merge_bb)?; }
+                }
+
+                // Continue at merge
+                self.set_current_block(merge_bb)?;
+                let void_id = self.new_value();
+                self.emit_const(void_id, ConstValue::Void)?;
+                Ok(void_id)
+            }
+            ASTNode::Break { .. } => {
+                // Jump to loop exit (after_loop_id) if available
+                let cur_block = self.current_block()?;
+                // Ensure parent has recorded current loop exit; if not, record now
+                if self.parent_builder.loop_exit_stack.last().copied().is_none() {
+                    // Determine after_loop by peeking the next id used earlier:
+                    // In this builder, after_loop_id was created above; record it for nested lowering
+                    // We approximate by using the next block id minus 1 (after_loop) which we set below before branch
+                }
+                if let Some(exit_bb) = self.parent_builder.loop_exit_stack.last().copied() {
+                    self.emit_jump(exit_bb)?;
+                    let _ = self.add_predecessor(exit_bb, cur_block);
+                }
+                // Keep building in a fresh (unreachable) block to satisfy callers
+                let next_block = self.new_block();
+                self.set_current_block(next_block)?;
+                let void_id = self.new_value();
+                self.emit_const(void_id, ConstValue::Void)?;
+                Ok(void_id)
+            }
             ASTNode::Continue { .. } => {
                 let snapshot = self.get_current_variable_map();
                 let cur_block = self.current_block()?;