feat: add region-linear fusion types to ephapaxiser

Extends the ephapaxiser ABI to support region-scoped resource tracking,
mirroring the Ephapax compiler's region-linear fusion:

- LinearResource: add `region: Option<String>` field to track which
  region a resource belongs to
- Violation: add RegionEscape and RegionLinearNotConsumed variants
- Display: format new violations with region context
- analyzer: set region to None (Phase 2 will populate via scope analysis)

All 45 tests pass. The region field is opt-in — existing ephapaxiser
manifests work unchanged. Phase 2 will add `[[regions]]` to the manifest
format and scope-aware analysis to the codegen pipeline.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: hyperpolymath

src/abi/mod.rs

@@ -146,6 +146,14 @@ pub struct LinearResource {
     pub state: OwnershipState,
     /// Where this resource was allocated (set during analysis).
     pub allocation_site: Option<SourceLocation>,
+    /// Which region this resource belongs to (if any).
+    ///
+    /// When set, the resource's lifetime is bounded by the region — it cannot
+    /// escape the region's scope. At region exit, all linear resources in the
+    /// region must have been consumed (AllLinearsConsumed from the formal proofs).
+    /// This field mirrors Ephapax's region-linear fusion: the region constraint
+    /// is orthogonal to the ownership state tracking.
+    pub region: Option<String>,
 }
 
 impl LinearResource {
@@ -158,6 +166,7 @@ impl LinearResource {
             kind,
             state: OwnershipState::Uninitialized,
             allocation_site: None,
+            region: None,
         }
     }
 }
@@ -183,6 +192,24 @@ pub enum Violation {
         /// Where the second (invalid) deallocation occurred.
         second_free: SourceLocation,
     },
+    /// Resource escapes its region scope — region escape.
+    RegionEscape {
+        /// Name of the escaping resource.
+        resource_name: String,
+        /// The region the resource belongs to.
+        region: String,
+        /// Where the escape was detected.
+        escape_site: SourceLocation,
+    },
+    /// Linear resource in a region not consumed before region exit.
+    RegionLinearNotConsumed {
+        /// Name of the unconsumed resource.
+        resource_name: String,
+        /// The region that is exiting.
+        region: String,
+        /// Where the resource was allocated.
+        allocation_site: SourceLocation,
+    },
     /// Resource was used after being deallocated — use-after-free.
     UseAfterFree {
         /// Name of the misused resource.
@@ -207,6 +234,20 @@ impl fmt::Display for Violation {
                     resource_name, first_free, second_free
                 )
             }
+            Self::RegionEscape { resource_name, region, escape_site } => {
+                write!(
+                    f,
+                    "REGION-ESCAPE: '{}' in region '{}' escapes at {}",
+                    resource_name, region, escape_site
+                )
+            }
+            Self::RegionLinearNotConsumed { resource_name, region, allocation_site } => {
+                write!(
+                    f,
+                    "REGION-LINEAR-NOT-CONSUMED: '{}' in region '{}' allocated at {} not consumed before region exit",
+                    resource_name, region, allocation_site
+                )
+            }
             Self::UseAfterFree { resource_name, free_site, use_site } => {
                 write!(
                     f,

src/codegen/analyzer.rs

@@ -167,6 +167,7 @@ pub fn analyse(
             kind: var.kind.clone(),
             state: var.state.clone(),
             allocation_site: Some(var.allocation_site.clone()),
+            region: None, // Phase 2: populated when scope-aware analysis is added.
         });
     }