Phase 21.3 WIP: Hako Source Checker improvements

## 🎯 Checker/Analyzer拡張

### ✅ 実装追加
- テストフレームワーク追加（tools/hako_check/tests/）
- ルール改善（HC003グローバルassign、HC040静的箱トップレベルassign）
- テストランナー（run_tests.sh）

### 🔧 Rust側修正
- AST utilities拡張（src/ast/utils.rs）
- MIR lowerers新設（src/mir/lowerers/）
- Parser制御フロー改善（src/parser/statements/control_flow.rs）
- Tokenizer識別子処理改善（src/tokenizer/lex_ident.rs）

### 📁 主要変更
- tools/hako_check/cli.hako - CLI改善
- tools/hako_check/hako_source_checker.hako - Checker core更新
- tools/hako_check/tests/ - NEW (テストケース追加)
- tools/hako_check/run_tests.sh - NEW (テストランナー)
- src/mir/lowerers/ - NEW (MIR lowering utilities)

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

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

src/mir/builder/stmts.rs

@@ -153,7 +153,7 @@ impl super::MirBuilder {
         self.hint_scope_enter(scope_id);
         let mut last_value = None;
         for statement in statements {
-            last_value = Some(self.build_expression(statement)?);
+            last_value = Some(self.build_statement(statement)?);
             // If the current block was terminated by this statement (e.g., return/throw),
             // do not emit any further instructions for this block.
             if is_current_block_terminated(self)? {
@@ -171,6 +171,55 @@ impl super::MirBuilder {
         Ok(out)
     }
 
+    /// Build a single statement node.
+    ///
+    /// Note:
+    /// - Stage-3 While/ForRange lowering is delegated to existing Loop/expr lowering
+    ///   or handled in a dedicated pass; this function does not emit ad-hoc control
+    ///   flow for them to avoid divergence from SSOT/loop_common.
+    pub(super) fn build_statement(&mut self, node: ASTNode) -> Result<ValueId, String> {
+        match node.clone() {
+            ASTNode::While { condition, body, .. } => {
+                // Desugar Stage-3 while into legacy loop(condition) { body }
+                let loop_node = ASTNode::Loop { condition, body, span: crate::ast::Span::unknown() };
+                self.build_expression(loop_node)
+            }
+            ASTNode::ForRange { var_name, start, end, body, .. } => {
+                use crate::ast::{Span, LiteralValue, BinaryOperator};
+                // local var initialization
+                let init = ASTNode::Local {
+                    variables: vec![var_name.clone()],
+                    initial_values: vec![Some(start)],
+                    span: Span::unknown(),
+                };
+                // condition: var_name < end
+                let cond = ASTNode::BinaryOp {
+                    left: Box::new(ASTNode::Variable { name: var_name.clone(), span: Span::unknown() }),
+                    operator: BinaryOperator::Less,
+                    right: end,
+                    span: Span::unknown(),
+                };
+                // step: var_name = var_name + 1
+                let step = ASTNode::Assignment {
+                    target: Box::new(ASTNode::Variable { name: var_name.clone(), span: Span::unknown() }),
+                    value: Box::new(ASTNode::BinaryOp {
+                        left: Box::new(ASTNode::Variable { name: var_name.clone(), span: Span::unknown() }),
+                        operator: BinaryOperator::Add,
+                        right: Box::new(ASTNode::Literal { value: LiteralValue::Integer(1), span: Span::unknown() }),
+                        span: Span::unknown(),
+                    }),
+                    span: Span::unknown(),
+                };
+                let mut loop_body = body.clone();
+                loop_body.push(step);
+                let loop_node = ASTNode::Loop { condition: Box::new(cond), body: loop_body, span: Span::unknown() };
+                let program = ASTNode::Program { statements: vec![init, loop_node], span: Span::unknown() };
+                self.build_expression(program)
+            }
+            other => self.build_expression(other),
+        }
+    }
+
 
     // Local declarations with optional initializers
     pub(super) fn build_local_statement(