refactor: reorganize expression parser with proper precedence hierarchy

[LunaStev]

This PR significantly refactors the expression parsing logic to implement a standard C-style operator precedence hierarchy. It replaces the previous parsing structure with a dedicated recursive descent approach, ensuring that complex expressions are evaluated in the correct order. Additionally, it introduces support for binary literals and fixes several type-related issues in the LLVM code generation for logical and bitwise operations.

Key Changes

1. Expression Parsing & Precedence

• 13-Level Precedence Hierarchy: Implemented a complete top-down parsing structure following industry standards (Assignment → Logical → Bitwise → Equality → Relational → Shift → Additive → Multiplicative → Unary → Primary).
• Unary Refactoring: Consolidated prefix operators (!, ~, &, deref) into a dedicated recursive function, allowing for nested unary expressions (e.g., !!x).
• Grouped Expressions: Added Expression::Grouped to properly handle and preserve parenthesized sub-expressions.

2. Lexer Improvements

• Binary Literals: Added support for the 0b prefix (e.g., 0b1010), using from_str_radix for accurate conversion to i64.
• Shift Operator Parsing: Moved << and >> from keyword-based matching to character-level matching in the lexer. Fixed the collision where < was matched before <<.

3. LLVM Code Generation & Type Safety

• Logical Coercion: Added a to_bool() helper to handle integer-to-boolean coercion, ensuring logical AND/OR operations work correctly with multi-bit integers.
• Bitwise Operations: Fully implemented BitwiseAnd, BitwiseOr, and BitwiseXor using native LLVM instructions.
• Shift Type Casting: Fixed type mismatch errors by ensuring the shift amount is explicitly cast to match the type of the value being shifted.
• Unary NOT Logic:
  • Enhanced LogicalNot (!) to correctly compare integers with zero.
  • Implemented BitwiseNot (~) using the LLVM not (XOR with -1) logic.

4. Code Quality & Consistency

• AST Cleanup: Added Operator::Not for consistency across unary operations.
• Signature Simplification: Cleaned up parser function signatures using std::iter::Peekable for better readability and performance.

Operator Precedence (Highest to Lowest)

1. Primary: Literals, Identifiers, Grouped ()
2. Unary: !, ~, &, deref
3. Multiplicative: *, /, %
4. Additive: +, -
5. Shift: <<, >>
6. Relational: <, <=, >, >=
7. Equality: ==, !=
8. Bitwise AND: &
9. Bitwise XOR: ^
10. Bitwise OR: |
11. Logical AND: &&
12. Logical OR: ||
13. Assignment: =, +=, -=, *=, /=, %=

Examples of Improved Behavior

// Now parsed correctly as: a + (b * c)
var result = a + b * c; 

// Now parsed correctly as: (a << 2) + 1
var shift = a << 2 + 1; 

// Boolean coercion: converts 1 to true before &&
if (1 && true) { ... } 

// Binary literal support
var mask = 0b1100_1010;

Benefits

• Compliance: Matches C/C++ operator standards.
• Maintainability: Clear separation of concerns within the parsing logic makes it easier to add new operators.
• Robustness: Explicit type casting and boolean coercion prevent common LLVM IR validation errors.