Phase 14: Fix StageLocker over-locking + PatchSet overlap resolution

- StageLocker: Grammar now only blocked by spelling locks when >50%
of the grammar diff falls INSIDE the spelling lock. Previously,
any boundary touch (even 1 char) blocked grammar entirely.
This fixes the Collision Dataset bug (32% pass rate) where
spelling locks bled into adjacent words and blocked grammar.

- PatchSet: Relaxed overlap resolution — patches with <50% overlap
of the smaller patch are allowed to coexist. This prevents
punctuation patches from dropping spelling patches on adjacent words.

Both fixes verified with unit tests.

src/nlp/correction_patch.py

@@ -96,6 +96,11 @@ class PatchSet:
         """
         Single owner per range. Deterministic resolution.
         Uses ORIGINAL coordinates for overlap detection.
+
+        Phase 14: Relaxed overlap — patches that touch at a boundary or
+        have minimal overlap (<= 50% of the smaller patch) are allowed
+        to coexist. This prevents punctuation patches from killing spelling
+        patches on adjacent words (e.g., 'المشروع.' punct vs 'في' spelling).
         """
         sorted_patches = sorted(
             self.patches,
@@ -106,11 +111,24 @@ class PatchSet:
         resolved = []
 
         for patch in sorted_patches:
-            overlaps = any(
-                patch.start_original < ce and patch.end_original > cs
-                for cs, ce in claimed_ranges
-            )
-            if not overlaps:
+            has_substantial_overlap = False
+            for cs, ce in claimed_ranges:
+                # Check if there's any overlap at all
+                if patch.start_original < ce and patch.end_original > cs:
+                    # Calculate overlap amount
+                    overlap_start = max(patch.start_original, cs)
+                    overlap_end = min(patch.end_original, ce)
+                    overlap_width = overlap_end - overlap_start
+                    # Compare to the smaller patch's width
+                    patch_width = max(1, patch.end_original - patch.start_original)
+                    claimed_width = max(1, ce - cs)
+                    smaller_width = min(patch_width, claimed_width)
+                    overlap_ratio = overlap_width / smaller_width
+                    if overlap_ratio > 0.5:
+                        has_substantial_overlap = True
+                        break
+
+            if not has_substantial_overlap:
                 resolved.append(patch)
                 claimed_ranges.append((patch.start_original, patch.end_original))
             else:

src/nlp/stage_locker.py

@@ -81,6 +81,13 @@ class StageLocker:
           is_locked_for(0, 5, 'grammar')     on spelling lock → False (grammar > spelling)
           is_locked_for(0, 5, 'punctuation') on spelling lock → True  (spelling > punctuation)
           is_locked_for(0, 5, 'grammar')     on protection lock → True (protection > grammar)
+
+        Phase 14 (StageLocker relaxation):
+          Grammar requesting on a spelling lock uses RELAXED overlap:
+          only blocked if >50% of the grammar diff falls inside the spelling lock.
+          This allows grammar to fix words ADJACENT to spelling-fixed words
+          (the "Collision Dataset" bug — spelling locks were bleeding into
+          neighboring words and blocking valid grammar corrections).
         """
         req_priority = STAGE_PRIORITY.get(requesting_stage, 0)
         for ls, le, owner in self.locked_spans:
@@ -94,6 +101,35 @@ class StageLocker:
                             f"owner={owner}({owner_priority})"
                         )
                     return True  # Blocked: owner is same or higher priority
+
+                # ── Phase 14: Relaxed overlap for grammar on spelling locks ──
+                # Grammar (3) outranks spelling (2) in priority, BUT we still
+                # want to protect the EXACT word spelling fixed. The relaxation:
+                # allow grammar if the overlap is < 50% of the grammar diff's
+                # width (i.e., the grammar diff is mostly OUTSIDE the lock).
+                # This catches boundary touches and small overlaps that happen
+                # when spelling locks bleed past word boundaries.
+                if requesting_stage == 'grammar' and owner == 'spelling':
+                    overlap_start = max(start, ls)
+                    overlap_end = min(end, le)
+                    overlap_width = max(0, overlap_end - overlap_start)
+                    diff_width = max(1, end - start)
+                    overlap_ratio = overlap_width / diff_width
+                    if overlap_ratio > 0.5:
+                        # Grammar diff is mostly inside spelling lock — block
+                        logger.info(
+                            f"[StageLocker] Grammar blocked (overlap={overlap_ratio:.0%}): "
+                            f"grammar[{start}:{end}] vs spelling[{ls}:{le}]"
+                        )
+                        return True
+                    else:
+                        # Grammar diff is mostly outside — allow
+                        if PIPELINE_DEBUG or overlap_width > 0:
+                            logger.info(
+                                f"[StageLocker] Grammar ALLOWED (overlap={overlap_ratio:.0%}): "
+                                f"grammar[{start}:{end}] vs spelling[{ls}:{le}]"
+                            )
+                        continue
                 else:
                     if PIPELINE_DEBUG:
                         logger.debug(