Make comptime failures loud

[mbenke]

Three comptime failures were silent. This branch turns each into a rejection
with a message, and pins the messages so they cannot quietly stop working.

Assigning to a comptime binding emitted structurally invalid Hull

MastEval drops the let when a comptime binding is discharged
but always re-emits the assignment, so the body referenced an undeclared
variable. Neither comptime checker looked at an assignment target, and the
pipeline never runs Language.Hull.TypeCheck on its own output, so only yule
caught it — well after a green build. The rule now lives in
Solcore.Frontend.ComptimeCheck, where source spans exist: a declared
comptime binding (let x : comptime word, or a comptime parameter) is
immutable, including against assignment from inside an assembly block, which
reaches enclosing variables by name. Parameters merely treated as comptime
because the result is comptime are unaffected — those are assumptions, not
declarations.

Fixing that exposed a flow-insensitivity hole: if / for / match discard
the environment their bodies produce, so let x = 5; x = <runtime>; f(x)
classified x as comptime. An unannotated let whose name is assigned
anywhere in the function now yields CTDeferred.

Fuel exhaustion was a bare putStrLn, so --warnings never did not
silence it, --warnings deny did not escalate it, and nothing could assert it.
It is now warning[SC0401] through the normal diagnostics path, reported from
a sticky flag rather than inferred from the remaining budget.

The Mast-level checker's open/closed function split was decorative.
fcOpen was true exactly when checkNothingLeftToSubstitute rejects
unconditionally, so the split only chose which message a doomed program got.
Collapsed to isValue; the module header now states the one rule the pass
enforces.

Two correctness bugs turned up while writing the fixture for the string
clone relaxation, both worse than anything above:

• tryCloneComptime erased a parameter from the clone's signature but left its
  value only in the partial evaluator's variable environment. That environment
  is cleared at every opaque assembly block and at every for loop, so one
  sload in the body and the clone referenced a parameter that no longer
  existed — again exit 0, again caught only by yule (Undefined variable: n). The literals are now substituted into the body at clone creation, and a
  parameter the body assigns to is not erased at all.
• evalFunBody walked past every statement-expression while extracting a
  callee's return value, so inlining silently dropped any statement whose
  result was discarded but whose effect was not. encodeNone in
  test/examples/dispatch/generic_sum.solc lost its entire ABI encoding —
  allocate a zeroed buffer, never write to it, read it back — and passed its
  contract test only because None encodes as zeros. The same hole let a
  comptime builtin's stub body (unimplemented(); return 0;) inline to its
  placeholder, so keccakWordLit(<runtime word>) compiled to return 0
  instead of being reported.

A residual call no longer counts as comptime. The Mast-level checker
classified an expression structurally: comptime if it was a literal, a
comptime-bound variable, or a call to a pure function with comptime
arguments. But this pass runs after partial evaluation has already had its
chance at every function, so a call that is still there is one the evaluator
declined to fold — a runtime computation whatever its shape. The obligation
is now discharged only by a value: a literal, or a constructor applied to
values. That is also what makes exhausted fuel a rejection rather than
silently worse code.

This subsumes #566. That PR excluded memory-op functions from the purity
notion feeding the classifier, so an unfoldable mload read would stop being
classified comptime; under the value rule any residual call is rejected,
memory or not, so computeComptimePureFuns and the memOk flag it needed
are gone (its fixture, ct_asm_mload_runtime.solc, still passes — the five
asmIsInterpretableWith False unit tests went with the function).

A second pass then rejects any comptime annotation that survives to emission
at all: every function reaching this point is about to be emitted, so a
comptime parameter means the argument was never substituted, and a comptime
return means no call to it was ever folded.

Assisted-By: Claude Opus 5