feat(joinir): Phase 27.8-1~3 — Ops Box導入 + Toggle対応完了

## Phase 27.8-1: JoinIR 命令意味箱（Ops Box）作成 ✅

**新規ファイル**: `src/mir/join_ir_ops.rs`
- `eval_binop()`: Add, Sub, Mul, Div, Or, And の評価ロジック一元化
- `eval_compare()`: Lt, Le, Gt, Ge, Eq, Ne の比較ロジック一元化
- エラー処理: `JoinIrOpError` 型で型安全
- 完全テストカバレッジ: 13個のユニットテスト

**効果**:
- BinOp/Compare の評価ロジックを一箇所に集約
- 再利用可能な API で将来の拡張が容易
- テスタビリティ向上

## Phase 27.8-2: join_ir_runner.rs の Ops Box 統合 ✅

**変更**: `src/mir/join_ir_runner.rs`
- BinOp/Compare の実装を ops box に完全移譲（約70行削減）
- `JoinValue` / `JoinIrOpError` を ops box から再エクスポート
- 後方互換性維持: `JoinRuntimeError = JoinIrOpError`

**効果**:
- コード重複削減（約70行）
- 実装の一貫性保証（ops box の単一実装を使用）

## Phase 27.8-3: MIR→JoinIR Toggle 対応 ✅

**変更**: `src/mir/join_ir.rs`
- `lower_skip_ws_to_joinir()`: トグル対応ディスパッチャー
- `lower_skip_ws_handwritten()`: 既存実装をリネーム（Phase 27.1-27.7）
- `lower_skip_ws_from_mir()`: MIR自動解析版スタブ（Phase 27.8-4 で実装予定）

**環境変数制御**:
```bash
# 手書き版（デフォルト）
./target/release/hakorune program.hako

# MIR自動解析版（Phase 27.8-4 実装予定）
NYASH_JOINIR_LOWER_FROM_MIR=1 ./target/release/hakorune program.hako
```

**効果**:
- 段階的な移行が可能（既存動作を完全に維持）
- A/B テストによる検証が容易

## 変更ファイル

- `src/mir/join_ir_ops.rs` (新規): Ops Box 実装
- `src/mir/join_ir_runner.rs`: Ops Box 使用に変更
- `src/mir/join_ir.rs`: Toggle 対応ディスパッチャー追加
- `src/mir/mod.rs`: join_ir_ops モジュール追加

## コンパイル結果

✅ 0 errors, 18 warnings（既存警告のみ）
✅ ビルド成功

## 次のステップ

**Phase 27.8-4**: `lower_skip_ws_from_mir()` 本実装
- MirQuery を使った MIR 解析
- パターンマッチング（init, header, break checks, body）
- JoinIR 自動生成（entry function + loop_step function）

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

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

src/mir/join_ir_runner.rs

@@ -4,41 +4,22 @@
 //! - 対応値: i64 / bool / String / Unit
 //! - 対応命令: Const / BinOp / Compare / BoxCall(StringBox: length, substring) /
 //!              Call / Jump / Ret
+//!
+//! Phase 27.8: ops box 統合
+//! - JoinValue / JoinIrOpError は join_ir_ops から再エクスポート
+//! - eval_binop() / eval_compare() を使用（実装を一箇所に集約）
 
 use std::collections::HashMap;
 
 use crate::mir::join_ir::{
-    BinOpKind, CompareOp, ConstValue, JoinFuncId, JoinInst, JoinModule, MirLikeInst, VarId,
+    ConstValue, JoinFuncId, JoinInst, JoinModule, MirLikeInst, VarId,
 };
 
-#[derive(Debug, Clone, PartialEq)]
-pub enum JoinValue {
-    Int(i64),
-    Bool(bool),
-    Str(String),
-    Unit,
-}
+// Phase 27.8: ops box からの再エクスポート
+pub use crate::mir::join_ir_ops::{JoinIrOpError, JoinValue};
 
-#[derive(Debug, Clone)]
-pub struct JoinRuntimeError {
-    pub message: String,
-}
-
-impl JoinRuntimeError {
-    fn new(msg: impl Into<String>) -> Self {
-        Self {
-            message: msg.into(),
-        }
-    }
-}
-
-impl std::fmt::Display for JoinRuntimeError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", self.message)
-    }
-}
-
-impl std::error::Error for JoinRuntimeError {}
+// Phase 27.8: 互換性のため JoinRuntimeError を JoinIrOpError の別名として保持
+pub type JoinRuntimeError = JoinIrOpError;
 
 pub fn run_joinir_function(
     module: &JoinModule,
@@ -144,81 +125,18 @@ fn eval_compute(inst: &MirLikeInst, locals: &mut HashMap<VarId, JoinValue>) -> R
             locals.insert(*dst, v);
         }
         MirLikeInst::BinOp { dst, op, lhs, rhs } => {
+            // Phase 27.8: ops box の eval_binop() を使用
             let l = read_var(locals, *lhs)?;
             let r = read_var(locals, *rhs)?;
-            let v = match op {
-                BinOpKind::Add => match (l, r) {
-                    (JoinValue::Int(a), JoinValue::Int(b)) => JoinValue::Int(a + b),
-                    (JoinValue::Str(a), JoinValue::Str(b)) => JoinValue::Str(format!("{a}{b}")),
-                    _ => {
-                        return Err(JoinRuntimeError::new(
-                            "Add supported only for (int,int) or (str,str)",
-                        ))
-                    }
-                },
-                BinOpKind::Sub => match (l, r) {
-                    (JoinValue::Int(a), JoinValue::Int(b)) => JoinValue::Int(a - b),
-                    _ => return Err(JoinRuntimeError::new("Sub supported only for integers")),
-                },
-                BinOpKind::Mul => match (l, r) {
-                    (JoinValue::Int(a), JoinValue::Int(b)) => JoinValue::Int(a * b),
-                    _ => return Err(JoinRuntimeError::new("Mul supported only for integers")),
-                },
-                BinOpKind::Div => match (l, r) {
-                    (JoinValue::Int(_), JoinValue::Int(0)) => {
-                        return Err(JoinRuntimeError::new("Division by zero"))
-                    }
-                    (JoinValue::Int(a), JoinValue::Int(b)) => JoinValue::Int(a / b),
-                    _ => return Err(JoinRuntimeError::new("Div supported only for integers")),
-                },
-                BinOpKind::Or => match (l, r) {
-                    (JoinValue::Bool(a), JoinValue::Bool(b)) => JoinValue::Bool(a || b),
-                    _ => return Err(JoinRuntimeError::new("Or supported only for bools")),
-                },
-                BinOpKind::And => match (l, r) {
-                    (JoinValue::Bool(a), JoinValue::Bool(b)) => JoinValue::Bool(a && b),
-                    _ => return Err(JoinRuntimeError::new("And supported only for bools")),
-                },
-            };
+            let v = crate::mir::join_ir_ops::eval_binop(*op, &l, &r)?;
             locals.insert(*dst, v);
         }
         MirLikeInst::Compare { dst, op, lhs, rhs } => {
+            // Phase 27.8: ops box の eval_compare() を使用
             let l = read_var(locals, *lhs)?;
             let r = read_var(locals, *rhs)?;
-            let v = match (l, r) {
-                (JoinValue::Int(a), JoinValue::Int(b)) => match op {
-                    CompareOp::Lt => a < b,
-                    CompareOp::Le => a <= b,
-                    CompareOp::Gt => a > b,
-                    CompareOp::Ge => a >= b,
-                    CompareOp::Eq => a == b,
-                    CompareOp::Ne => a != b,
-                },
-                (JoinValue::Bool(a), JoinValue::Bool(b)) => match op {
-                    CompareOp::Eq => a == b,
-                    CompareOp::Ne => a != b,
-                    _ => {
-                        return Err(JoinRuntimeError::new(
-                            "Bool comparison only supports Eq/Ne in the JoinIR runner",
-                        ))
-                    }
-                },
-                (JoinValue::Str(a), JoinValue::Str(b)) => match op {
-                    CompareOp::Eq => a == b,
-                    CompareOp::Ne => a != b,
-                    _ => {
-                        return Err(JoinRuntimeError::new(
-                            "String comparison only supports Eq/Ne in the JoinIR runner",
-                        ))
-                    }
-                },
-                _ => {
-                    return Err(JoinRuntimeError::new(
-                        "Type mismatch in Compare (expected homogeneous operands)",
-                    ))
-                }
-            };
-            locals.insert(*dst, JoinValue::Bool(v));
+            let v = crate::mir::join_ir_ops::eval_compare(*op, &l, &r)?;
+            locals.insert(*dst, v);
         }
         MirLikeInst::BoxCall {
             dst,