feat(plan): Phase 273 P2 Step 3-6 - Pattern7 (SplitScan) to Plan line

Migrate Pattern7 from legacy lowering to Plan architecture:

DomainPlan (mod.rs):
- Added SplitScan(SplitScanPlan) variant
- SplitScanPlan: s_var, sep_var, result_var, i_var, start_var

Extractor (pattern7_split_scan.rs):
- extract_split_scan_plan() returning DomainPlan
- Reuses existing extract_split_scan_parts()

Router (router.rs):
- Pattern7 now uses Plan line (Normalize→Verify→Lower)
- Removed from LOOP_PATTERNS table

Normalizer (normalizer.rs):
- normalize_split_scan() - 400+ lines migrated from impl
- 6 blocks: preheader/header/body/then/else/step/after
- 4 PHIs: header(2) + step(2) for i/start carriers
- Side effect: push with EffectMask::MUT

Bug fixes:
- Pattern6 extractor returns Ok(None) for non-match (allows fallback)
- Reverse scan filtered early in extractor (P1 scope)

Tests:
- phase256_p0_split_vm: PASS (exit=3)
- phase258_p0_index_of_string_vm: PASS (exit=6)

Lowerer no longer contains "split" - pattern-agnostic achieved!

🤖 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/router.rs

@@ -236,11 +236,8 @@ pub(crate) static LOOP_PATTERNS: &[LoopPatternEntry] = &[
     },
     // Phase 273 P0.1: Pattern6 entry removed (migrated to Plan-based routing)
     // Pattern6_ScanWithInit now handled via extract_scan_with_init_plan() + PlanLowerer
-    LoopPatternEntry {
-        name: "Pattern7_SplitScan", // Phase 256 P0: split/tokenization with variable step (before P3)
-        detect: super::pattern7_split_scan::can_lower,
-        lower: super::pattern7_split_scan::lower,
-    },
+    // Phase 273 P2: Pattern7 entry removed (migrated to Plan-based routing)
+    // Pattern7_SplitScan now handled via extract_split_scan_plan() + PlanLowerer
     LoopPatternEntry {
         name: "Pattern8_BoolPredicateScan", // Phase 259 P0: boolean predicate scan (is_integer/is_valid)
         detect: super::pattern8_scan_bool_predicate::can_lower,
@@ -325,6 +322,37 @@ pub(crate) fn route_loop_pattern(
         }
     }
 
+    // Phase 273 P2: Try Plan-based Pattern7 (SplitScan)
+    // Flow: Extract → Normalize → Verify → Lower
+    match super::pattern7_split_scan::extract_split_scan_plan(
+        ctx.condition,
+        ctx.body,
+        &[],
+    )? {
+        Some(domain_plan) => {
+            // DomainPlan extracted successfully
+            trace::trace().pattern("route", "Pattern7_SplitScan (DomainPlan)", true);
+
+            // Step 1: Normalize DomainPlan → CorePlan
+            let core_plan = PlanNormalizer::normalize(builder, domain_plan, ctx)?;
+
+            // Step 2: Verify CorePlan invariants (fail-fast)
+            PlanVerifier::verify(&core_plan)?;
+
+            // Step 3: Lower CorePlan → MIR
+            return PlanLowerer::lower(builder, core_plan, ctx);
+        }
+        None => {
+            // Not Pattern7 - continue to other patterns
+            if ctx.debug {
+                trace::trace().debug(
+                    "route",
+                    "Pattern7 Plan extraction returned None, trying other patterns",
+                );
+            }
+        }
+    }
+
     // Phase 183: Route based on pre-classified pattern kind
     // Pattern kind was already determined by ctx.pattern_kind in LoopPatternContext::new()
     // This eliminates duplicate detection logic across routers.