feat: implement increment/decrement operators and semantic mutability validation

[LunaStev]

This PR introduces support for standard C-style increment (++) and decrement (--) operators in both prefix and postfix forms. Additionally, it implements a new semantic verification layer to enforce mutability rules, ensuring that variables are only modified when explicitly declared as mutable.

Key Changes

1. AST & Parser Enhancements

• Increment/Decrement: Added IncDec expression variant and IncDecKind (PreInc, PreDec, PostInc, PostDec) to the AST.
• Operator Parsing:
  • Updated parse_unary_expression to handle prefix operators.
  • Enhanced parse_expression with lookahead logic to identify postfix operators.
• L-Value Validation: Implemented is_assignable checks to ensure ++/-- are only applied to valid targets (variables, array indices, struct fields, and dereferenced pointers).

2. New Semantic Verification Module

• Mutability Pass: Introduced a verification module that performs a full AST traversal before code generation.
• Scope Tracking: The validator tracks variable bindings and their Mutability status.
• Safety Enforcement: The compiler now produces errors if a modification (assignment or inc/dec) is attempted on an immutable binding (e.g., let x = 5; x++; will now fail during semantic analysis).

3. LLVM Code Generation

• Inc/Dec Logic: Implemented the load -> add/sub -> store pattern for all supported types:
  • Integers: Standard integer arithmetic.
  • Floats: Floating-point arithmetic.
  • Pointers: Pointer arithmetic (incrementing by the size of the underlying type).
• Pre/Post Behavior: Correctly handles the return value based on timing (prefix returns the modified value; postfix returns the original value).
• Codegen Fixes: Improved generate_address_ir to robustly handle grouped expressions and complex dereferences.

4. Testing & Documentation

• Integration Tests: Added test72.wave and test73.wave.
• Coverage: Tests verify increment/decrement behavior across basic types and pointer dereferences, as well as the newly implemented mutability constraints.

Example Usage

var count: i32 = 10;
count++;       // Post-increment: returns 10, count becomes 11
++count;       // Pre-increment: returns 12, count becomes 12

let mut p: ptr<i32> = &count;
deref p += 1;  // Dereference modification
(deref p)++;   // Incrementing the value pointed to

Benefits

• Expressiveness: Adds common shorthand operators expected in C-family languages.
• Safety: Strengthens type safety by preventing accidental modifications of immutable data.
• Consistency: Ensures pointer arithmetic behaves consistently with standard integer types.