feat(mir): Loop Canonicalizer Phase 4 - router parity verification

## Summary
既存 Router と Canonicalizer の選択が一致することを dev-only で検証。
不一致は理由付き Fail-Fast（strict mode）。

## Changes
- src/mir/builder/control_flow/joinir/routing.rs:
  - verify_router_parity() 実装
  - cf_loop_joinir_impl でパリティチェック呼び出し
  - 2つのユニットテスト追加
    - test_parity_check_mismatch_detected
    - test_parity_check_match_simple_while
- docs/development/current/main/phases/phase-137/phase-137-4-parity-verification.md:
  - Phase 4 完全ドキュメント

## Verification Modes
- Debug mode (HAKO_JOINIR_DEBUG=1): ログのみ
- Strict mode (HAKO_JOINIR_STRICT=1): 不一致でエラー

## Known Mismatch
- skip_whitespace pattern:
  - Canonicalizer: Pattern3IfPhi (構造認識)
  - Router: Pattern2Break (has_break優先)
  - Phase 5+ で分類ルール改善予定

## Tests
- Unit tests: 2 tests PASS
- Integration: skip_whitespace parity mismatch 検出確認
- cargo test --release --lib: 1046/1046 PASS

Phase 137-4 complete

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

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

src/mir/builder/control_flow/joinir/routing.rs

@@ -6,6 +6,77 @@ use crate::mir::builder::MirBuilder;
 use crate::mir::ValueId;
 
 impl MirBuilder {
+    /// Phase 137-4: Verify router parity between canonicalizer and router
+    ///
+    /// Dev-only: Ensures the canonicalizer's pattern choice matches the router's
+    /// pattern_kind. On mismatch:
+    /// - Debug mode (HAKO_JOINIR_DEBUG=1): Log warning
+    /// - Strict mode (HAKO_JOINIR_STRICT=1): Return error
+    fn verify_router_parity(
+        &self,
+        condition: &ASTNode,
+        body: &[ASTNode],
+        func_name: &str,
+        ctx: &super::patterns::LoopPatternContext,
+    ) -> Result<(), String> {
+        use crate::ast::Span;
+        use crate::mir::loop_canonicalizer::canonicalize_loop_expr;
+
+        // Reconstruct loop AST for canonicalizer
+        let loop_ast = ASTNode::Loop {
+            condition: Box::new(condition.clone()),
+            body: body.to_vec(),
+            span: Span::unknown(),
+        };
+
+        // Run canonicalizer
+        let (_, decision) = canonicalize_loop_expr(&loop_ast)
+            .map_err(|e| format!("[loop_canonicalizer/PARITY] Canonicalizer error: {}", e))?;
+
+        // Compare patterns only if canonicalizer succeeded
+        if let Some(canonical_pattern) = decision.chosen {
+            let actual_pattern = ctx.pattern_kind;
+
+            if canonical_pattern != actual_pattern {
+                // Pattern mismatch detected
+                let msg = format!(
+                    "[loop_canonicalizer/PARITY] MISMATCH in function '{}': \
+                     canonical={:?}, actual={:?}",
+                    func_name, canonical_pattern, actual_pattern
+                );
+
+                // Check strict mode
+                let is_strict = std::env::var("HAKO_JOINIR_STRICT").is_ok()
+                    || std::env::var("NYASH_JOINIR_STRICT").is_ok();
+
+                if is_strict {
+                    // Strict mode: fail fast
+                    return Err(msg);
+                } else {
+                    // Debug mode: log only
+                    eprintln!("{}", msg);
+                }
+            } else {
+                // Patterns match - success!
+                eprintln!(
+                    "[loop_canonicalizer/PARITY] OK in function '{}': \
+                     canonical and actual agree on {:?}",
+                    func_name, canonical_pattern
+                );
+            }
+        } else {
+            // Canonicalizer failed (Fail-Fast)
+            // Log but don't error - router might still handle it
+            eprintln!(
+                "[loop_canonicalizer/PARITY] Canonicalizer failed for '{}': {}",
+                func_name,
+                decision.notes.join("; ")
+            );
+        }
+
+        Ok(())
+    }
+
     /// Phase 49: Try JoinIR Frontend for mainline integration
     ///
     /// Returns `Ok(Some(value))` if the loop is successfully lowered via JoinIR,
@@ -122,7 +193,7 @@ impl MirBuilder {
         func_name: &str,
         debug: bool,
     ) -> Result<Option<ValueId>, String> {
-        // Phase 137-2: Dev-only observation via Loop Canonicalizer
+        // Phase 137-2/137-4: Dev-only observation via Loop Canonicalizer
         if crate::config::env::joinir_dev_enabled() {
             use crate::ast::Span;
             use crate::mir::loop_canonicalizer::canonicalize_loop_expr;
@@ -149,6 +220,20 @@ impl MirBuilder {
                     if decision.is_fail_fast() {
                         eprintln!("[loop_canonicalizer]   Reason: {}", decision.notes.join("; "));
                     }
+
+                    // Phase 137-4: Router parity verification
+                    if let Some(canonical_pattern) = decision.chosen {
+                        // Get actual pattern from router (will be determined by LoopPatternContext)
+                        // We need to defer this check until after ctx is created
+                        // Store decision for later parity check
+                        trace::trace().debug(
+                            "canonicalizer",
+                            &format!(
+                                "Phase 137-4: Canonical pattern chosen: {:?} (parity check pending)",
+                                canonical_pattern
+                            ),
+                        );
+                    }
                 }
                 Err(e) => {
                     eprintln!("[loop_canonicalizer] Function: {}", func_name);
@@ -182,6 +267,11 @@ impl MirBuilder {
             LoopPatternContext::new(condition, body, &func_name, debug)
         };
 
+        // Phase 137-4: Router parity verification (after ctx is created)
+        if crate::config::env::joinir_dev_enabled() {
+            self.verify_router_parity(condition, body, func_name, &ctx)?;
+        }
+
         if let Some(result) = route_loop_pattern(self, &ctx)? {
             trace::trace().routing("router", func_name, "Pattern router succeeded");
             return Ok(Some(result));
@@ -198,3 +288,170 @@ impl MirBuilder {
         self.cf_loop_joinir_legacy_binding(condition, body, func_name, debug)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::ast::{ASTNode, BinaryOperator, LiteralValue, Span};
+
+    /// Test helper: Create a skip_whitespace pattern loop AST
+    fn build_skip_whitespace_loop() -> ASTNode {
+        ASTNode::Loop {
+            condition: Box::new(ASTNode::BinaryOp {
+                operator: BinaryOperator::Less,
+                left: Box::new(ASTNode::Variable {
+                    name: "p".to_string(),
+                    span: Span::unknown(),
+                }),
+                right: Box::new(ASTNode::Variable {
+                    name: "len".to_string(),
+                    span: Span::unknown(),
+                }),
+                span: Span::unknown(),
+            }),
+            body: vec![ASTNode::If {
+                condition: Box::new(ASTNode::BinaryOp {
+                    operator: BinaryOperator::Equal,
+                    left: Box::new(ASTNode::Variable {
+                        name: "is_ws".to_string(),
+                        span: Span::unknown(),
+                    }),
+                    right: Box::new(ASTNode::Literal {
+                        value: LiteralValue::Integer(1),
+                        span: Span::unknown(),
+                    }),
+                    span: Span::unknown(),
+                }),
+                then_body: vec![ASTNode::Assignment {
+                    target: Box::new(ASTNode::Variable {
+                        name: "p".to_string(),
+                        span: Span::unknown(),
+                    }),
+                    value: Box::new(ASTNode::BinaryOp {
+                        operator: BinaryOperator::Add,
+                        left: Box::new(ASTNode::Variable {
+                            name: "p".to_string(),
+                            span: Span::unknown(),
+                        }),
+                        right: Box::new(ASTNode::Literal {
+                            value: LiteralValue::Integer(1),
+                            span: Span::unknown(),
+                        }),
+                        span: Span::unknown(),
+                    }),
+                    span: Span::unknown(),
+                }],
+                else_body: Some(vec![ASTNode::Break {
+                    span: Span::unknown(),
+                }]),
+                span: Span::unknown(),
+            }],
+            span: Span::unknown(),
+        }
+    }
+
+    #[test]
+    fn test_parity_check_mismatch_detected() {
+        use crate::mir::loop_canonicalizer::canonicalize_loop_expr;
+        use crate::mir::builder::control_flow::joinir::patterns::ast_feature_extractor as ast_features;
+
+        let loop_ast = build_skip_whitespace_loop();
+
+        // Extract condition and body
+        let (condition, body) = match &loop_ast {
+            ASTNode::Loop { condition, body, .. } => (condition.as_ref(), body.as_slice()),
+            _ => panic!("Expected loop node"),
+        };
+
+        // Run canonicalizer
+        let (_, canonical_decision) = canonicalize_loop_expr(&loop_ast).unwrap();
+        let canonical_pattern = canonical_decision.chosen.expect("Canonicalizer should succeed");
+
+        // Run router's pattern detection
+        let has_continue = ast_features::detect_continue_in_body(body);
+        let has_break = ast_features::detect_break_in_body(body);
+        let features = ast_features::extract_features(condition, body, has_continue, has_break);
+        let actual_pattern = crate::mir::loop_pattern_detection::classify(&features);
+
+        // Verify mismatch
+        // Canonicalizer: Pattern3IfPhi (recognizes if-else structure)
+        // Router: Pattern2Break (sees has_break)
+        assert_eq!(
+            canonical_pattern,
+            crate::mir::loop_pattern_detection::LoopPatternKind::Pattern3IfPhi
+        );
+        assert_eq!(
+            actual_pattern,
+            crate::mir::loop_pattern_detection::LoopPatternKind::Pattern2Break
+        );
+        assert_ne!(canonical_pattern, actual_pattern, "Phase 137-4: This test verifies mismatch detection");
+    }
+
+    #[test]
+    fn test_parity_check_match_simple_while() {
+        use crate::mir::loop_canonicalizer::canonicalize_loop_expr;
+        use crate::mir::builder::control_flow::joinir::patterns::ast_feature_extractor as ast_features;
+
+        // Simple while loop: no break, no continue, no if
+        let loop_ast = ASTNode::Loop {
+            condition: Box::new(ASTNode::BinaryOp {
+                operator: BinaryOperator::Less,
+                left: Box::new(ASTNode::Variable {
+                    name: "i".to_string(),
+                    span: Span::unknown(),
+                }),
+                right: Box::new(ASTNode::Literal {
+                    value: LiteralValue::Integer(10),
+                    span: Span::unknown(),
+                }),
+                span: Span::unknown(),
+            }),
+            body: vec![ASTNode::Assignment {
+                target: Box::new(ASTNode::Variable {
+                    name: "i".to_string(),
+                    span: Span::unknown(),
+                }),
+                value: Box::new(ASTNode::BinaryOp {
+                    operator: BinaryOperator::Add,
+                    left: Box::new(ASTNode::Variable {
+                        name: "i".to_string(),
+                        span: Span::unknown(),
+                    }),
+                    right: Box::new(ASTNode::Literal {
+                        value: LiteralValue::Integer(1),
+                        span: Span::unknown(),
+                    }),
+                    span: Span::unknown(),
+                }),
+                span: Span::unknown(),
+            }],
+            span: Span::unknown(),
+        };
+
+        // Extract condition and body
+        let (condition, body) = match &loop_ast {
+            ASTNode::Loop { condition, body, .. } => (condition.as_ref(), body.as_slice()),
+            _ => panic!("Expected loop node"),
+        };
+
+        // Canonicalizer will fail for simple patterns (not yet implemented)
+        let canonical_result = canonicalize_loop_expr(&loop_ast);
+
+        // Router's pattern detection
+        let has_continue = ast_features::detect_continue_in_body(body);
+        let has_break = ast_features::detect_break_in_body(body);
+        let features = ast_features::extract_features(condition, body, has_continue, has_break);
+        let actual_pattern = crate::mir::loop_pattern_detection::classify(&features);
+
+        // Router should classify as Pattern1SimpleWhile
+        assert_eq!(
+            actual_pattern,
+            crate::mir::loop_pattern_detection::LoopPatternKind::Pattern1SimpleWhile
+        );
+
+        // Canonicalizer should fail (not implemented yet for Pattern1)
+        assert!(canonical_result.is_ok());
+        let (_, decision) = canonical_result.unwrap();
+        assert!(decision.is_fail_fast(), "Canonicalizer should fail for simple patterns (Phase 3 only supports skip_whitespace)");
+    }
+}