Aiur grammar: statement sequencing t; rest

[arthurpaulino]

Add syntax:0 aiur_trm "; " (aiur_trm)? — f(x); rest elaborates to
let _ = f(x); rest (wildcard let, value discarded); trailing f(x);
closes the block with (). Unit-returning calls sit in statement
position without the let _ = boilerplate.

The sequencing rule is the grammar's only prec-0 rule; positions where
an expression can end right before a ; are bumped to prec 1 so it
can't leak into expression operands: let right-hand sides, +/-
right operands, return, array elements/replicate. Without the binop
guard, let x = a - 1; rest reparses as a - (1; rest) — caught only
at ix codegen scope-check (unboundGlobal), not by lake build,
since elaboration builds Source.Term without checking. All other
argument positions are bounded by closing tokens and can't precede a
;. Since prec-51 positions accept every leading form, default rule
prec ≥ 51 and the :1 annotations exclude only the sequencing rule.

Rewrite all 113 let _ = call(...); sites in Ix/IxVM and the 3
let _ = store(...) sites in Tests/Aiur to the new form, and drop the
4 redundant explicit () continuations after trailing assert_eq!
(an omitted continuation already elaborates to unit). Generated kernel
is byte-identical after lake exe ix codegen (identical IR by
construction — no FFT shift), and lake test -- aiur-cross passes
with the new syntax exercised.