fix(stdlib): single-ownership dedup of prelude/option/result (#133)

Per ADR-011 (#132): one canonical binding per name, module-owned.

- prelude.affine: `module prelude;`. Keeps the core sum types
  `Option`/`Result` (+ constructors) as their canonical home and the
  generic list/numeric utilities. Removes the 8 duplicate/conflicting
  Option/Result *operations* it previously also defined (is_some,
  is_none, unwrap, unwrap_or, is_ok, is_err, unwrap_result,
  unwrap_or_result).
- option.affine: `module option;` + `use prelude::{Option, Some, None,
  Result, Ok, Err};`. Now the single canonical home for Option ops.
- result.affine: `module result;` + `use prelude::{Result, Ok, Err,
  Option, Some, None};`. Single canonical home for Result ops.

The previous flat-namespace conflicts (`prelude.map(arr,f)` vs
`option.map(f,opt)`; `prelude.unwrap`(Option) vs `result.unwrap`(Result))
are resolved by module ownership — each is now `module::name`, exactly
one definition per owning module. Verified: no leftover dup defs, no
prelude util calls a removed op, full suite green (214 tests).

Note: this removes the prelude `unwrap`/`unwrap_result` that #134
(PR #150) patched; the sound, panicking versions are `option::unwrap`
and `result::unwrap` (already correct). #150's regression tests remain
valid against those. Merge-order: if #150 lands first, resolve the
modify/delete in prelude.affine in favour of this deletion.

Closes #133
Refs #128, #132

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

Author: hyperpolymath

stdlib/option.affine

@@ -3,7 +3,14 @@
 //
 // Option - Utilities for Option<T> type
 
-// Option type is defined in prelude, but here are utilities
+module option;
+
+// `Option`/`Result` types + constructors are owned by `prelude` (ADR-011).
+use prelude::{Option, Some, None, Result, Ok, Err};
+
+// This module is the single canonical home for the Option *operations*
+// (is_some/is_none/unwrap/unwrap_or/map/filter/contains/…). #133 removed
+// the duplicate copies that previously also lived in prelude.affine.
 
 // ============================================================================
 // Combinators

stdlib/prelude.affine

@@ -2,80 +2,24 @@
 // AffineScript Standard Library - Prelude
 // Common functions and utilities automatically available
 
+module prelude;
+
 // ============================================================================
-// Option type - represents optional values
+// Core sum types (canonical home — ADR-011)
+//
+// `Option` and `Result` (and their constructors) are owned here, the
+// foundational module. The `option` / `result` modules provide the
+// *operations* over them and `use prelude::{...}` for the types. The
+// duplicate/conflicting Option/Result ops that previously lived here
+// (is_some, is_none, unwrap, unwrap_or, is_ok, is_err, unwrap_result,
+// unwrap_or_result) were removed in #133: option::* and result::* are
+// the single canonical bindings for those.
 // ============================================================================
 
 type Option<T> = Some(T) | None
 
-fn is_some<T>(opt: Option<T>) -> Bool {
-  match opt {
-    Some(_) => true,
-    None => false
-  }
-}
-
-fn is_none<T>(opt: Option<T>) -> Bool {
-  match opt {
-    Some(_) => false,
-    None => true
-  }
-}
-
-fn unwrap<T>(opt: Option<T>) -> T {
-  match opt {
-    Some(value) => value,
-    None => {
-      println("Called unwrap on None");
-      // TODO: panic!() once implemented
-    }
-  }
-}
-
-fn unwrap_or<T>(opt: Option<T>, default: T) -> T {
-  match opt {
-    Some(value) => value,
-    None => default
-  }
-}
-
-// ============================================================================
-// Result type - represents success or failure
-// ============================================================================
-
 type Result<T, E> = Ok(T) | Err(E)
 
-fn is_ok<T, E>(res: Result<T, E>) -> Bool {
-  match res {
-    Ok(_) => true,
-    Err(_) => false
-  }
-}
-
-fn is_err<T, E>(res: Result<T, E>) -> Bool {
-  match res {
-    Ok(_) => false,
-    Err(_) => true
-  }
-}
-
-fn unwrap_result<T, E>(res: Result<T, E>) -> T {
-  match res {
-    Ok(value) => value,
-    Err(_) => {
-      println("Called unwrap on Err");
-      // TODO: panic!() once implemented
-    }
-  }
-}
-
-fn unwrap_or_result<T, E>(res: Result<T, E>, default: T) -> T {
-  match res {
-    Ok(value) => value,
-    Err(_) => default
-  }
-}
-
 // ============================================================================
 // List utilities
 // ============================================================================

stdlib/result.affine

@@ -3,7 +3,15 @@
 //
 // Result - Error handling with Result<T, E> type
 
-// Result type is defined in prelude, but here are utilities
+module result;
+
+// `Option`/`Result` types + constructors are owned by `prelude` (ADR-011).
+use prelude::{Result, Ok, Err, Option, Some, None};
+
+// This module is the single canonical home for the Result *operations*
+// (is_ok/is_err/unwrap/unwrap_or/map_ok/map_err/…). #133 removed the
+// duplicate/redundant copies (is_ok/is_err/unwrap_result/unwrap_or_result)
+// that previously also lived in prelude.affine.
 
 // ============================================================================
 // Constructors and Conversions