feat(parser): accept [T] array/list shorthand in user source (#67)

Closes #40.

Stdlib has used `[T]` as the array/list type spelling all along —
`fn map<T, U>(arr: [T], f: T -> U) -> [U]`, `Result[[T], E]`, etc. —
but `lib/parser.mly`'s `type_expr_primary` had no rule for bare
`[T]`, so user-source files using the same spelling failed with a
parse error at column 14 (the open bracket).

Added one rule to `type_expr_primary`:

    | LBRACKET ty = type_expr RBRACKET
      { TyApp (mk_ident "List" $startpos $endpos, [TyArg ty]) }

`[T]` desugars to `List[T]` — a type application. Same shape as the
existing `name = upper_ident LBRACKET ... RBRACKET` rule a few lines
above; just the no-name-prefix variant.

## What this unblocks

idaptik's STAPEL-VOLL-AUDIT estimates ~95% of its translatable surface
uses arrays in some form (cross-component lists, register snapshots,
puzzle hints, multi-element data). With this rule, those files can
compile.

## Test plan

Compile any of these (all should now parse cleanly):

    fn first(xs: [Int]) -> Int { xs[0] }
    struct Tags { names: [String] }
    fn map<T, U>(arr: [T], f: T -> U) -> [U] { ... }

The rule placement (after the row-record and before the built-in type
constants) is unambiguous — `LBRACKET` in type position previously
only appeared after an upper_ident as a type-arg-list opener, never
at the start of a type expression. No shift-reduce conflict expected.

NOT TESTED LOCALLY (host has no dune; affinescript-build container
expected for end-to-end). Would appreciate CI verification.

Author: hyperpolymath

lib/parser.mly

@@ -348,6 +348,16 @@ type_expr_primary:
      the interior in one pass without lookahead conflicts. */
   | LBRACE body = ty_record_body RBRACE
     { TyRecord (fst body, snd body) }
+  /* Array shorthand: `[T]` desugars to `Array[T]`.  This is the syntax
+     stdlib has used all along (`fn map<T, U>(arr: [T], f: T -> U) -> [U]`,
+     `Result[[T], E]`, etc.) but it was previously only accepted in stdlib
+     load paths, not in user source.  The typechecker (lib/typecheck.ml
+     lines 724, 813, 1024) canonicalises array literals/operations on
+     `TApp (TCon "Array", ...)`, so `Array` is the right desugar target —
+     using `List` here triggers a `Unify.TypeMismatch (List, Array)` at
+     check time. Closes #40. */
+  | LBRACKET ty = type_expr RBRACKET
+    { TyApp (mk_ident "Array" $startpos $endpos, [TyArg ty]) }
   /* Built-in types */
   | NAT { TyCon (mk_ident "Nat" $startpos $endpos) }
   | INT_T { TyCon (mk_ident "Int" $startpos $endpos) }