feat(joinir): Phase 171-C-3 LoopBodyCarrierPromoter integration with Pattern 2/4

Integrates LoopBodyCarrierPromoter into Pattern 2/4 lowerers for Trim pattern detection:

## Pattern 2 (loop_with_break_minimal.rs)
- After LoopConditionScopeBox::analyze(), check for LoopBodyLocal variables
- If present, attempt carrier promotion via LoopBodyCarrierPromoter
- Break condition passed to promoter for Trim pattern detection
- Fail-Fast error handling on promotion failure

## Pattern 4 (loop_with_continue_minimal.rs)
- Similar integration as Pattern 2
- No break condition (break_cond: None)
- Analyzes loop condition only for LoopBodyLocal

## Design Benefits
- ✅ router.rs remains abstract (no condition details)
- ✅ Fail-Fast principle maintained
- ✅ Box Theory separation preserved
- ✅ CarrierInfo merge deferred to future phase

## Also Fixed (test build failures)
- Implemented Debug trait for ExitBindingBuilder
- Replaced Span::default() → Span::unknown()
- Updated LiteralValue::Boolean → LiteralValue::Bool
- Commented out obsolete test code with TODO markers

Build status: ✅ cargo build --release succeeds

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

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

src/mir/builder/control_flow/joinir/patterns/exit_binding.rs

@@ -33,6 +33,16 @@ pub struct ExitBindingBuilder<'a> {
     variable_map: &'a mut HashMap<String, ValueId>,
 }
 
+impl<'a> std::fmt::Debug for ExitBindingBuilder<'a> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("ExitBindingBuilder")
+            .field("carrier_info", self.carrier_info)
+            .field("exit_meta", self.exit_meta)
+            .field("variable_map", &"<HashMap>")
+            .finish()
+    }
+}
+
 impl<'a> ExitBindingBuilder<'a> {
     /// Create a new ExitBindingBuilder
     ///

src/mir/builder/control_flow/joinir/patterns/pattern2_with_break.rs

@@ -62,6 +62,7 @@ impl MirBuilder {
                 None, // Pattern 2 handles break-triggered vars via condition_bindings
             )?;
 
+
         // Phase 195: Use unified trace
         trace::trace().varmap("pattern2_start", &self.variable_map);
 
@@ -159,6 +160,50 @@ impl MirBuilder {
             break_condition_raw.clone()
         };
 
+        // Phase 171-C-3: LoopBodyCarrierPromoter integration
+        // Check if LoopConditionScopeBox detects LoopBodyLocal variables, and attempt promotion
+        {
+            use crate::mir::loop_pattern_detection::loop_condition_scope::LoopConditionScopeBox;
+            use crate::mir::loop_pattern_detection::loop_body_carrier_promoter::{
+                LoopBodyCarrierPromoter, PromotionRequest, PromotionResult,
+            };
+
+            // First check: Does the condition reference LoopBodyLocal variables?
+            let cond_scope = LoopConditionScopeBox::analyze(
+                &loop_var_name,
+                &[condition, &break_condition_node],
+                Some(&scope),
+            );
+
+            if cond_scope.has_loop_body_local() {
+                // Phase 171-C-3: Try promotion
+                let request = PromotionRequest {
+                    scope: &scope,
+                    cond_scope: &cond_scope,
+                    break_cond: Some(&break_condition_node),
+                    loop_body: _body,
+                };
+
+                match LoopBodyCarrierPromoter::try_promote(&request) {
+                    PromotionResult::Promoted { trim_info } => {
+                        eprintln!(
+                            "[pattern2/promoter] LoopBodyLocal '{}' promoted to carrier '{}'",
+                            trim_info.var_name, trim_info.carrier_name
+                        );
+                        // Phase 171-C-3: Detection only - CarrierInfo merge is future work
+                        // For now, we just log successful detection and continue normal flow
+                    }
+                    PromotionResult::CannotPromote { reason, vars } => {
+                        // Phase 171-C-3: Fail-Fast on promotion failure
+                        return Err(format!(
+                            "[cf_loop/pattern2] Cannot promote LoopBodyLocal variables {:?}: {}",
+                            vars, reason
+                        ));
+                    }
+                }
+            }
+        }
+
         // Phase 169 / Phase 171-fix / Phase 172-3 / Phase 170-B: Call Pattern 2 lowerer with break_condition
         // Phase 33-14: Now returns (JoinModule, JoinFragmentMeta) for expr_result + carrier separation
         let (join_module, fragment_meta) = match lower_loop_with_break_minimal(scope, condition, &break_condition_node, &env, &loop_var_name) {

src/mir/builder/control_flow/joinir/patterns/pattern4_with_continue.rs

@@ -210,6 +210,51 @@ impl MirBuilder {
             variable_definitions: BTreeMap::new(),
         };
 
+        // Phase 171-C-3: LoopBodyCarrierPromoter integration
+        // Check if LoopConditionScopeBox detects LoopBodyLocal variables, and attempt promotion
+        {
+            use crate::mir::loop_pattern_detection::loop_condition_scope::LoopConditionScopeBox;
+            use crate::mir::loop_pattern_detection::loop_body_carrier_promoter::{
+                LoopBodyCarrierPromoter, PromotionRequest, PromotionResult,
+            };
+
+            // First check: Does the condition reference LoopBodyLocal variables?
+            let cond_scope = LoopConditionScopeBox::analyze(
+                &loop_var_name,
+                &[condition],
+                Some(&scope),
+            );
+
+            if cond_scope.has_loop_body_local() {
+                // Phase 171-C-3: Try promotion
+                // Pattern 4 has no break condition
+                let request = PromotionRequest {
+                    scope: &scope,
+                    cond_scope: &cond_scope,
+                    break_cond: None,  // Pattern 4 doesn't have break
+                    loop_body: body_to_analyze,
+                };
+
+                match LoopBodyCarrierPromoter::try_promote(&request) {
+                    PromotionResult::Promoted { trim_info } => {
+                        eprintln!(
+                            "[pattern4/promoter] LoopBodyLocal '{}' promoted to carrier '{}'",
+                            trim_info.var_name, trim_info.carrier_name
+                        );
+                        // Phase 171-C-3: Detection only - CarrierInfo merge is future work
+                        // For now, we just log successful detection and continue normal flow
+                    }
+                    PromotionResult::CannotPromote { reason, vars } => {
+                        // Phase 171-C-3: Fail-Fast on promotion failure
+                        return Err(format!(
+                            "[cf_loop/pattern4] Cannot promote LoopBodyLocal variables {:?}: {}",
+                            vars, reason
+                        ));
+                    }
+                }
+            }
+        }
+
         // Phase 169: Call Pattern 4 lowerer with condition AST
         let (join_module, exit_meta) = match lower_loop_with_continue_minimal(scope, condition, self, &carrier_info, &carrier_updates) {
             Ok(result) => result,