feat: implement generics, explicit type casting, and static globals

[LunaStev]

This PR introduces a major leap in Wave's expressiveness and system-level capabilities. It implements the foundational infrastructure for Generic Programming, introduces explicit Type Casting via the as operator, and adds support for Global Static Variables. Additionally, it matures the compiler's cross-platform architecture with robust target-specific preprocessing and granular backend control for x86_64 and ARM64.

---

Key Changes

1. Generic Programming (Generics)

• Infrastructure: Added generic_params to FunctionNode and StructNode, and type_args to function calls/struct initializers.
• Nested Parsing: Enhanced the type parser to correctly handle complex nested generic arguments (e.g., ptr<TypedBuffer<i32>>).
• Monomorphization: Integrated a monomorphization pass into the compilation runner to generate specialized LLVM IR for generic instances.
• Stdlib Expansion: Refactored core modules to provide reusable generic utilities, including TypedBuffer<T>, ptr_swap<T>, and numeric functions like num_abs<T> and num_min<T>.

2. Language Primitives: static, as, and null

• Static Globals: Introduced the static keyword for declaring global variables with persistent storage in the LLVM data segment.
• Explicit Casting (as): Added the as keyword for explicit type conversions (e.g., x as i64), providing safe widening/narrowing and pointer-to-integer casts.
• Native null: Added a formal null literal, ensuring strict type compatibility with pointer types across the backend.

3. Backend & Cross-Platform Robustness

• Target Customization: Expanded BackendOptions to allow users to override target triples, CPU architectures, and ABIs via the CLI.
• ABI Refinement: Overhauled abi_c.rs to support the System V ABI for both x86_64 and ARM64 on Linux and macOS (Darwin), including optimized aggregate splitting for Apple Silicon.
• Intelligent Preprocessing: Rebuilt the #[target(os="...")] preprocessor to be "context-aware," ensuring it ignores braces and semicolons inside comments or string literals.

4. Tooling & Documentation

• Tiered Platform Policy: Updated README.md to formalize Tiers 1–4 of platform support, setting clear expectations for architecture stability.
• Advanced CLI: Added specialized --llvm and -C flags for fine-grained backend and linker control.
• Ecosystem: Added a reference to the doom.wave example to showcase the language's capabilities.

---

Example Usage

Generics & Type Casting:

#[target(os="linux")]
fun platform_id() -> i32 {
    return 1;
}

#[target(os="macos")]
fun platform_id() -> i32 {
    return 2;
}

struct Box<T> {
    value: T;
}

struct Pair<A, B> {
    first: A;
    second: B;
}

fun identity<T>(x: T) -> T {
    return x;
}

fun wrap<T>(x: T) -> Box<T> {
    var boxed: Box<T>;
    boxed.value = x;
    return boxed;
}

fun make_pair<A, B>(a: A, b: B) -> Pair<A, B> {
    var pair_value: Pair<A, B>;
    pair_value.first = a;
    pair_value.second = b;
    return pair_value;
}

fun first_of<A, B>(p: Pair<A, B>) -> A {
    return p.first;
}

fun main() -> i32 {
    var a: i32 = identity<i32>(10);
    if (a != 10) {
        return 1;
    }

    var boxed_i64: Box<i64> = wrap<i64>(1234);
    if (boxed_i64.value != 1234) {
        return 2;
    }

    var p: Pair<i32, i64> = make_pair<i32, i64>(7, 99);
    if (p.first != 7) {
        return 3;
    }

    if (p.second != 99) {
        return 4;
    }

    var nested: Box<Box<i32>> = wrap<Box<i32>>(wrap<i32>(42));
    if (nested.value.value != 42) {
        return 5;
    }

    var p_first: i32 = first_of<i32, i64>(p);
    if (p_first != 7) {
        return 6;
    }

    var os: i32 = platform_id();
    if (os != 1 && os != 2) {
        return 7;
    }

    return 0;
}

---

Benefits

• Code Reusability: Generics allow for writing algorithms (like swap or min) once and using them across any type.
• System Control: static and as provide the low-level primitives necessary for memory-mapped I/O and OS development.
• Portability: The improved target preprocessor and ARM64 ABI support make Wave a viable tool for modern cross-platform systems programming.