feat: implement enums, type aliases, and advanced constant evaluation

[LunaStev]

This PR significantly expands the Wave type system and compile-time capabilities. It introduces enum and type alias support, supported by a new pre-codegen Type Resolution Pass. Additionally, the constant evaluation engine has been overhauled to support complex nested aggregates and iterative dependency resolution, while the ABI layer has been hardened for safer C FFI interactions.

Key Changes

1. Enums & Type Aliases

• Enum Syntax: Introduced enum Name -> Repr { Variant, ... }. Variants are automatically treated as global constants of the specified representation type.
• Type Aliasing: Added the type Alias = Target syntax, allowing for cleaner and more descriptive type naming.
• Type Resolution Pass: Implemented a mandatory pass before code generation that flattens type aliases and resolves enum references across the entire AST (functions, structs, variables).

2. Advanced Constant Evaluation

• Aggregate Support: The constant evaluator now supports struct literals and array literals, allowing complex data structures to be defined at compile-time.
• Iterative Resolution: Implemented a multi-round resolution strategy. Constants can now depend on other constants regardless of their declaration order in the source code.
• Extended Keyword Support: true, false, and null are now valid primary expressions in constant contexts.

3. Backend & ABI Improvements

• Safe Aggregate Packing: Refactored the FFI packing/unpacking logic (pack_agg_to_int) to use build_memcpy instead of raw bit-casting. This ensures that alignment requirements are respected when passing small structs through integer registers.
• Vector Coercion: Added support for coercing aggregates to LLVM Vector types, improving the handling of Homogeneous Floating-point Aggregates (HFAs) in the System V ABI.
• Project Hygiene: The backend now automatically ensures the target/ directory exists before emitting object files.

4. Parser & Verification

• New Keywords: Registered type and enum as reserved keywords.
• Identifier Validation: Enhanced the semantic verification pass to detect and error on the usage of undeclared identifiers in expressions.
• Global Registration: The verification pass now correctly registers enum variants as global constants, making them available project-wide.

Example Usage

type MyInt = i32;

enum ShaderUniformType -> MyInt {
    A = 0,
    B,
    C = 10,
    D
}

const X: MyInt = 123;
const Y: MyInt = B;
const Z: ShaderUniformType = D;

fun f(t: ShaderUniformType) -> MyInt {
    return t;
}

fun g(v: MyInt) -> MyInt {
    return v;
}

fun main() {
    println("{}", f(A)); // 0
    println("{}", f(B)); // 1
    println("{}", f(C)); // 10
    println("{}", f(D)); // 11

    println("{}", g(X)); // 123
    println("{}", g(Y)); // 1
    println("{}", f(Z)); // 11
}

Benefits

• Flexibility: Type aliases and enums allow for much more expressive and maintainable codebases.
• Compile-time Power: Complex constant evaluation reduces runtime overhead by shifting computations to the compiler.
• FFI Robustness: Using memcpy for aggregate packing prevents subtle memory corruption bugs related to data alignment during C library calls.