Match named arguments by NAME, and read Int32 as Int

MoonBit lets a call reorder its named arguments freely -- settled against
`moon check`, `ActionCommand::new(intent=..., label=..., group=...,
description=..., shortcut=...)` is accepted for a signature declared
`(intent~, label?, shortcut?, enabled?, group?, description?)`. So an
argument's INDEX is not its parameter's index as soon as any argument is
named, and the argument-type check compares one against the other. It was
comparing `args[3]` to `params[3]` and reporting "argument 4 ... has
incompatible type 'str'; expected 'bool'" six times from `moui
core/gesture.mbt:754` onward, where `description` is passed fourth and
`enabled` is declared fourth.

ECall and EMethodCall now carry the argument labels, parse_call_args returns
them, and each argument is matched by label, falling back to its index only
when it has no label or the label names no parameter. The `x~` shorthand is a
label too: it is read back out of the token stream by `Parser::name_at`,
after the value has already been parsed, so it reorders like any other.

Separately, 0.1.20261012 renamed the default integer type, and the formatter
applied that rename to this project's OWN source. `ann_to_ty` did not know
`Int32`, so it read as Unknown and the argument-type check went quiet on 87
parameters of ours. Settled in both directions against `moon check`: an Int
is accepted by an Int32 parameter and an Int32 by an Int parameter, so it is
a synonym.

Int64 and UInt are deliberately NOT folded into TInt. Settled: a UInt passed
to an Int parameter is an Expr Type Mismatch, and so is the reverse, and so
is Int64 against either. Folding them in would silence this reader on exactly
the mismatches `moon check` reports, which is the 0.4.5 failure with the sign
flipped. They stay Unknown until they get their own Ty variants; corpus
weight for that work is 122 `: Int64` and 23 `: UInt` across proton + async
+ moui.

Corpora (wzzc-dev/moui 0.1.12): readable files unchanged at 481, actionable
8 -> 1, the seven that go being one shape and all false. moonbit_labeler,
async, proton, moonbit_image and proton_contract are byte-identical.

The `all_positional` arity gate -- label-addressed calls are exempt from the
positional count check -- is kept as a measured leniency rather than a fix:
`moon check` rejects every shape it covers (duplicate label 4084, unknown
label 4085), and across the six corpora it changes exactly one finding, an
arity report in `moui backend/web/web_host.mbt` past that file's
reliable-region boundary, so it lands in the `unreliable` bucket.

Tests: js 360 / wasm 432 / wasm-gc 360, seventeen new. Every fixture was
settled against `moon check` before it was written. The sharp test asserts
zero findings, so it is paired with tests that assert exactly one -- a check
switched off would also produce zero.

The mutation gate (`_verify/mutate_0422.ps1`, eight mutations, six killed)
found three things the fixtures were hiding. A top-level `let r = build()`
in a fixture makes the behavioral lens re-report the call as MethodError,
which merges with the type lens under `(merge family, line)`, so
count_family("ArgTypeMismatch") reads 0 whatever the matcher does: with
param_index broken to never match, all 432 tests still passed. Two
mismatching arguments on one line likewise collapse into one. And
parse_call_args pushes to args and labels at four separate sites, the one for
an argument with no leading name being different from the one for a leading
name; dropping that push does not fail, it just leaves `labels` shorter than
`args` so every argument after the gap reads a later argument's label.

M7 (the arity gate) and M8 (method-call labels) survive and are recorded as
such with their reasons. M8 is a real gap: infer discards EMethodCall labels
because method arguments are not type-checked at all -- there is no receiver
signature to check them against.

Self-check 59/59, actionable=0, unreliable=0, withheld=0.