refactor(joinir): Phase 286C-2.1 - 3-stage pipeline scaffolding (Scan/Plan/Apply)

- Create 3-stage pipeline architecture to solve borrow checker conflicts
- Stage 1 (ScanBox): Read-only scanning, identify rewrites (170 lines)
- Stage 2 (PlanBox): Pure transformation, generate new blocks (85 lines)
- Stage 3 (ApplyBox): Builder mutation only (75 lines)

New Files:
- scan_box.rs: Stage 1 - Read-only scan for RewritePlan
- plan_box.rs: Stage 2 - Transform RewritePlan → RewrittenBlocks
- apply_box.rs: Stage 3 - Apply RewrittenBlocks to MirBuilder
- C-2.1-pipeline-refactoring.md: Implementation guide

Data Structures:
- RewritePlan: Describes WHAT to rewrite (tail calls, returns, PHI, params)
- RewrittenBlocks: Contains HOW to rewrite (new blocks, replacements, inputs)

Benefits:
- Borrow checker safety: No overlapping mutable/immutable borrows
- Single responsibility: Each stage has one clear purpose
- Testability: Each stage can be unit tested independently
- Maintainability: Clear data flow, isolated changes

Status:
- Scaffolding: ✅ Complete (structure defined, stub implementations)
- Integration: ⏳ Next step (refactor merge_and_rewrite to use 3 stages)

Build: cargo build --release ✅

🤖 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/merge/rewriter/apply_box.rs

@@ -0,0 +1,63 @@
+//! ApplyBox: Builder mutation only (RewrittenBlocks → MirBuilder)
+//!
+//! Phase 286C-2.1: Third stage of 3-stage pipeline (Scan → Plan → Apply)
+//! Adds/replaces blocks in MirBuilder WITHOUT reading/analyzing.
+
+use crate::mir::builder::MirBuilder;
+use crate::mir::{BasicBlock, BasicBlockId};
+
+use super::plan_box::RewrittenBlocks;
+
+/// ApplyBox: Builder mutation only
+pub struct ApplyBox;
+
+impl ApplyBox {
+    /// Apply rewritten blocks to the MirBuilder
+    ///
+    /// This is the ONLY stage that mutates the builder.
+    /// It doesn't analyze or plan - just adds/replaces blocks.
+    ///
+    /// # Arguments
+    /// * `builder` - The MirBuilder to mutate
+    /// * `blocks` - The rewritten blocks from PlanBox
+    ///
+    /// # Returns
+    /// * Result indicating success or failure
+    pub fn apply(builder: &mut MirBuilder, blocks: RewrittenBlocks) -> Result<(), String> {
+        // Add new blocks
+        if let Some(ref mut current_func) = builder.scope_ctx.current_function {
+            for block in blocks.new_blocks {
+                current_func.add_block(block);
+            }
+
+            // Replace existing blocks
+            for (block_id, new_block) in blocks.block_replacements {
+                current_func.blocks.insert(block_id, new_block);
+            }
+        }
+
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::mir::builder::MirBuilder;
+    use std::collections::BTreeMap;
+
+    #[test]
+    fn test_apply_box_basic() {
+        // Basic smoke test
+        let mut builder = MirBuilder::new();
+        let blocks = RewrittenBlocks {
+            new_blocks: Vec::new(),
+            block_replacements: BTreeMap::new(),
+            phi_inputs: Vec::new(),
+            carrier_inputs: BTreeMap::new(),
+        };
+
+        let result = ApplyBox::apply(&mut builder, blocks);
+        assert!(result.is_ok());
+    }
+}

src/mir/builder/control_flow/joinir/merge/rewriter/mod.rs

@@ -43,6 +43,11 @@ pub(super) mod tail_call_detector_box; // Phase 286C-2 Step 2: Tail call detecti
 pub(super) mod terminator; // Phase 260 P0.1 Step 5: Terminator remapping extracted ✅
 pub(super) mod type_propagation; // Phase 260 P0.1 Step 4: Type propagation extracted ✅
 
+// Phase 286C-2.1: 3-stage pipeline (Scan → Plan → Apply) ✅
+pub(super) mod scan_box; // Stage 1: Read-only scanning for rewrite planning
+pub(super) mod plan_box; // Stage 2: Pure transformation (scan → blocks)
+pub(super) mod apply_box; // Stage 3: Builder mutation only
+
 // Re-export public API
  // Phase 260 P0.1 Step 3: From helpers ✅
 pub(super) use super::instruction_rewriter::merge_and_rewrite; // Still in parent (TODO: extract)

src/mir/builder/control_flow/joinir/merge/rewriter/plan_box.rs

@@ -0,0 +1,70 @@
+//! PlanBox: Pure transformation (Scan → RewrittenBlocks)
+//!
+//! Phase 286C-2.1: Second stage of 3-stage pipeline (Scan → Plan → Apply)
+//! Generates new blocks and mappings WITHOUT touching the builder.
+
+use crate::mir::{BasicBlock, BasicBlockId, ValueId};
+use std::collections::BTreeMap;
+
+use super::scan_box::RewritePlan;
+
+/// Rewritten blocks: New blocks, PHI inputs, carrier inputs (ready to apply)
+#[derive(Debug, Clone)]
+pub struct RewrittenBlocks {
+    /// New blocks to add to the builder
+    pub new_blocks: Vec<BasicBlock>,
+
+    /// Block replacements: Map<block_id, new_block>
+    pub block_replacements: BTreeMap<BasicBlockId, BasicBlock>,
+
+    /// PHI inputs for exit block: Vec<(from_block, value)>
+    pub phi_inputs: Vec<(BasicBlockId, ValueId)>,
+
+    /// Carrier inputs: Map<carrier_name, Vec<(from_block, value)>>
+    pub carrier_inputs: BTreeMap<String, Vec<(BasicBlockId, ValueId)>>,
+}
+
+/// PlanBox: Pure transformation from RewritePlan to RewrittenBlocks
+pub struct PlanBox;
+
+impl PlanBox {
+    /// Transform a RewritePlan into RewrittenBlocks
+    ///
+    /// This is a PURE transformation - no builder mutation, no side effects.
+    /// Can update RewriteContext but does NOT touch MirBuilder.
+    ///
+    /// # Arguments
+    /// * `plan` - The rewrite plan from ScanBox
+    ///
+    /// # Returns
+    /// * RewrittenBlocks ready to be applied to the builder
+    pub fn transform(_plan: RewritePlan) -> RewrittenBlocks {
+        // TODO: Implement transformation logic
+        // For now, return empty result
+        RewrittenBlocks {
+            new_blocks: Vec::new(),
+            block_replacements: BTreeMap::new(),
+            phi_inputs: Vec::new(),
+            carrier_inputs: BTreeMap::new(),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_plan_box_basic() {
+        // Basic smoke test
+        let plan = RewritePlan {
+            tail_calls: Vec::new(),
+            return_conversions: Vec::new(),
+            phi_adjustments: Vec::new(),
+            parameter_bindings: Vec::new(),
+        };
+
+        let blocks = PlanBox::transform(plan);
+        assert!(blocks.new_blocks.is_empty());
+    }
+}

src/mir/builder/control_flow/joinir/merge/rewriter/scan_box.rs

@@ -0,0 +1,162 @@
+//! ScanBox: Read-only scanning for rewrite planning
+//!
+//! Phase 286C-2.1: First stage of 3-stage pipeline (Scan → Plan → Apply)
+//! Identifies what needs to be rewritten WITHOUT mutating any state.
+
+use crate::mir::{BasicBlock, BasicBlockId, MirFunction, MirInstruction, ValueId};
+use std::collections::BTreeSet;
+
+/// Rewrite plan: Describes WHAT to do (doesn't touch instructions yet)
+#[derive(Debug, Clone)]
+pub struct RewritePlan {
+    /// Tail calls to be converted to parameter bindings + Jump
+    pub tail_calls: Vec<TailCallRewrite>,
+
+    /// Return instructions to convert to Jump to exit block
+    pub return_conversions: Vec<ReturnConversion>,
+
+    /// PHI adjustments needed (currently empty, for future use)
+    pub phi_adjustments: Vec<PhiAdjustment>,
+
+    /// Parameter bindings to generate for tail calls
+    pub parameter_bindings: Vec<ParameterBinding>,
+}
+
+/// Information about a tail call to rewrite
+#[derive(Debug, Clone)]
+pub struct TailCallRewrite {
+    /// Block containing the tail call
+    pub block_id: BasicBlockId,
+
+    /// Target function name
+    pub target_func_name: String,
+
+    /// Target block (entry block of called function)
+    pub target_block: BasicBlockId,
+
+    /// Remapped arguments to pass
+    pub args: Vec<ValueId>,
+
+    /// Whether this is a recursive call (same function)
+    pub is_recursive: bool,
+
+    /// Whether this is a continuation call (k_exit, etc.)
+    pub is_continuation: bool,
+
+    /// Whether the target is the loop entry function
+    pub is_loop_entry: bool,
+}
+
+/// Information about a Return instruction to convert
+#[derive(Debug, Clone)]
+pub struct ReturnConversion {
+    /// Block containing the Return
+    pub block_id: BasicBlockId,
+
+    /// Return value (if any)
+    pub return_value: Option<ValueId>,
+
+    /// Whether this has exit edge args
+    pub has_exit_edge_args: bool,
+
+    /// Whether to keep Return (non-skippable continuation)
+    pub should_keep_return: bool,
+}
+
+/// PHI adjustment (placeholder for future use)
+#[derive(Debug, Clone)]
+pub struct PhiAdjustment {
+    /// Block containing the PHI
+    pub block_id: BasicBlockId,
+
+    /// PHI destination
+    pub phi_dst: ValueId,
+}
+
+/// Parameter binding to generate
+#[derive(Debug, Clone)]
+pub struct ParameterBinding {
+    /// Block to insert the binding into
+    pub block_id: BasicBlockId,
+
+    /// Destination ValueId (parameter)
+    pub dst: ValueId,
+
+    /// Source ValueId (argument)
+    pub src: ValueId,
+}
+
+/// ScanBox: Read-only scanning for rewrite planning
+pub struct ScanBox;
+
+impl ScanBox {
+    /// Scan a block to identify rewrite operations needed
+    ///
+    /// This is a READ-ONLY operation - it doesn't mutate any state,
+    /// just analyzes what needs to be done.
+    ///
+    /// # Arguments
+    /// * `block` - The block to scan
+    /// * `block_id` - The block's ID
+    /// * `func_name` - The function containing this block
+    /// * Additional context parameters (TODO: consolidate into ScanContext)
+    ///
+    /// # Returns
+    /// * Instructions to skip, tail calls found, returns to convert, etc.
+    pub fn scan_block(
+        block: &BasicBlock,
+        block_id: BasicBlockId,
+        _func_name: &str,
+    ) -> BlockScanResult {
+        let mut skip_instructions = BTreeSet::new();
+        let mut found_tail_call = false;
+
+        // Scan instructions for tail calls, returns, etc.
+        for (idx, inst) in block.instructions.iter().enumerate() {
+            match inst {
+                MirInstruction::Call { .. } => {
+                    // Detect tail calls
+                    // TODO: Implement tail call detection logic
+                    found_tail_call = false; // Placeholder
+                }
+                MirInstruction::Return { .. } => {
+                    // Mark return for conversion
+                    // TODO: Implement return conversion detection
+                }
+                _ => {}
+            }
+        }
+
+        BlockScanResult {
+            skip_instructions,
+            found_tail_call,
+            tail_call_target: None,
+        }
+    }
+}
+
+/// Result of scanning a single block
+#[derive(Debug, Clone)]
+pub struct BlockScanResult {
+    /// Instruction indices to skip during rewriting
+    pub skip_instructions: BTreeSet<usize>,
+
+    /// Whether a tail call was found
+    pub found_tail_call: bool,
+
+    /// Tail call target (if found)
+    pub tail_call_target: Option<(BasicBlockId, Vec<ValueId>)>,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_scan_box_basic() {
+        // Basic smoke test - will expand with real logic
+        let block = BasicBlock::new(BasicBlockId(0));
+        let result = ScanBox::scan_block(&block, BasicBlockId(0), "test_func");
+        assert!(!result.found_tail_call);
+    }
+}