This commit introduces support for user-defined Algebraic Data Types (ADTs) and pattern matching constructs.
Key changes include:
1.  **Syntax (`Syntax.hs`):**
    *   Added `TAlgebraicData Text` to `Type` for representing ADT types.
    *   Introduced `ConstructorDef Text [Type]` for defining constructors.
    *   Added `DataDef Text [ConstructorDef]` to `Definition` for ADT declarations (e.g., `data MyType [ Cons1 : number -> MyType ];`).
    *   Added `Pattern` (PConstructor, PVar, PWildcard), `Clause`, and `Match Expr [Clause]` to `Expr` for pattern matching expressions (e.g., `branch expr [ (Pattern) -> result_expr ];`).
2.  **Parser (`Parser.hs`):**
    *   Implemented parsers for `data` declarations, constructor definitions (name and argument types), and ADT names as types.
    *   Implemented parsers for `branch` expressions, including individual clauses and patterns (constructor, variable, wildcard).
    *   Integrated these new parsers into the existing grammar.
3.  **Type Checker (`TypeChecker.hs`):**
    *   Extended `TypeState` to store `AdtInfo` (constructors and their signatures).
    *   **ADT Declaration Processing:**
        *   Added logic to register ADTs and their constructors. Constructor names are added to the global environment with their functional types (e.g., `Cons : T1 -> T2 -> MyADT`).
        *   Implemented type validation for constructor arguments, supporting recursive ADT definitions.
        *   Added checks for ADT/constructor name collisions.
    *   **Pattern Matching Type Checking:**
        *   Implemented type inference for `Match` expressions.
        *   Validated that the scrutinee is an ADT type.
        *   Type-checked patterns against the scrutinee's ADT, binding variables with correct types within each branch.
        *   Ensured all branches of a match expression return a unifiable type.
        *   **Exhaustiveness Checking:** Implemented checks to ensure patterns cover all constructors of an ADT, throwing an error for non-exhaustive matches unless a wildcard or variable pattern is present.
    *   Effects from the scrutinee and the chosen branch are combined for the match expression.
4.  **Tests (`examples/`):**
    *   Added `adt_simple_def.mmt`: Basic ADT definition and usage.
    *   Added `adt_exhaustiveness.mmt`: Testing exhaustiveness checks (success and failure cases).
    *   Added `adt_type_errors.mmt`: Testing various type errors in ADT definitions and pattern matching (branch type mismatch, arity errors, etc.).
    *   Added `adt_recursive.mmt`: Testing recursive ADT definitions and usage (e.g., a list).
These changes allow you to define complex data structures and deconstruct them safely using pattern matching, enhancing the language's expressiveness and type safety.