feat: add module import examples and standard library

Module system was already implemented - this adds examples and stdlib:

examples/modules/:
- math_utils.lux: Reusable math functions (square, cube, factorial)
- string_utils.lux: String utilities (repeat, exclaim, greet)
- main.lux: Basic module import example
- main_selective.lux: Selective imports {fn1, fn2}
- main_wildcard.lux: Wildcard imports (module.*)
- use_stdlib.lux: Using the standard library

std/:
- prelude.lux: Core utilities (identity, compose, flip, not, and, or)
- io.lux: I/O helpers (println, readLine, debug)
- option.lux: Option utilities (some, none, map, flatMap, filter)
- result.lux: Result utilities (ok, err, mapOk, mapErr)

Import syntax supports:
- import path/to/module       (access as module.fn)
- import path/to/module as x  (access as x.fn)
- import path/to/module.{a,b} (access as a, b directly)
- import path/to/module.*     (all exports directly)

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

std/option.lux

@@ -0,0 +1,57 @@
+// Option type utilities
+// For working with optional values
+
+/// Wrap a value in Some
+pub fn some<T>(value: T): Option<T> = Some(value)
+
+/// The None value
+pub fn none<T>(): Option<T> = None
+
+/// Check if option has a value
+pub fn isSome<T>(opt: Option<T>): Bool =
+    match opt {
+        Some(_) => true,
+        None => false
+    }
+
+/// Check if option is empty
+pub fn isNone<T>(opt: Option<T>): Bool =
+    match opt {
+        Some(_) => false,
+        None => true
+    }
+
+/// Get value or default
+pub fn unwrapOr<T>(opt: Option<T>, default: T): T =
+    match opt {
+        Some(v) => v,
+        None => default
+    }
+
+/// Map over the value if present
+pub fn map<T, U>(opt: Option<T>, f: fn(T): U): Option<U> =
+    match opt {
+        Some(v) => Some(f(v)),
+        None => None
+    }
+
+/// FlatMap (bind) for options
+pub fn flatMap<T, U>(opt: Option<T>, f: fn(T): Option<U>): Option<U> =
+    match opt {
+        Some(v) => f(v),
+        None => None
+    }
+
+/// Filter option by predicate
+pub fn filter<T>(opt: Option<T>, pred: fn(T): Bool): Option<T> =
+    match opt {
+        Some(v) => if pred(v) then Some(v) else None,
+        None => None
+    }
+
+/// Convert Option to List (empty or singleton)
+pub fn toList<T>(opt: Option<T>): List<T> =
+    match opt {
+        Some(v) => [v],
+        None => []
+    }