Add unsafe pointer syntax/runtime support with typed *type and type[n] declarations

[Copilot]

The language now supports pointer-style operations inside unsafe contexts while keeping safe code pointer-free by default. This includes typed pointer declarations, fixed-size typed buffers, and core pointer operators with runtime bounds enforcement.

• Type syntax + parser updates

  • Added unsafe type forms:
    • *type for pointers (e.g. *u8)
    • type[n] for fixed-size arrays (e.g. u8[1024])
  • Extended expression parsing for unary pointer operators:
    • address-of &
    • dereference *
  • Preserved safe-by-default behavior by gating pointer type parsing to unsafe declaration contexts.

• Unsafe runtime pointer model

  • Introduced a pointer runtime value carrying:
    • backing container
    • current index
    • pointed element type
  • Implemented:
    • &buffer[i] address-of on indexed arrays/lists
    • *ptr dereference
    • ptr +/- int pointer arithmetic

• Safety constraints in unsafe mode

  • Enforced pointer operations only in unsafe execution contexts (unsafe class/method flow).
  • Added bounds checks for:
    • pointer creation from indexed access
    • pointer arithmetic result
    • pointer dereference

• Type handling + field initialization

  • Extended type validation/concrete typing for pointer values and sized array signatures.
  • Added default initialization for sized unsafe fields (type[n]) and pointer fields in object construction paths.

• Feature example

  x: int = 42
  
  unsafe LowLevel {
      ptr: *u8
      buffer: u8[1024]
  
      method() {
          ptr = &buffer[0]
          value := *ptr
          ptr = ptr + 16
      }
  }