Painless: cancellation_aware augmentation infrastructure - #150092

Extend Phase 1's static-call-site handling to def-dispatched call sites
so def-typed receivers (def l = ...; l.each(...)) also route through the
cancellation-aware augmentation overload.

Compile-time:
- IRDecorations gains IRCMaybeNeedsScriptThis, attached during IR
  construction to a def call when the method name is in the lookup's
  cancellationAwareMethodNames set.  The set is populated only for
  cancellation-aware contexts, so the condition never fires in others.
- visitInvokeCallDef checks the condition AND that the enclosing
  function caches #cancelRunnable.  When both are true: emits aload 0
  (script this) ahead of user args, prefixes the recipe with 'S', and
  adds ScriptThis.class to the descriptor's typeParameters.

Runtime:
- DefBootstrap.bootstrap peels the 'S' prefix before counting lambdas
  so the args.length validation isn't off by one.
- Def.lookupMethod peels the prefix, decrements numArguments, and
  threads the offset through the lambda-binding loop's descriptor
  indexing.  After resolving the target method, if it doesn't carry
  CancellationAwareAnnotation the handle is wrapped with
  MethodHandles.dropArguments to discard the script-this slot — this
  handles the false-positive case where a user class happens to share
  a name with a cancellation-aware augmentation.

Per-call cost in cancellation-aware contexts: one aload 0 per def call
whose method name is in the cancellation-aware set (small set; gated
out for unrelated names like toString, get, etc).  Non-cancellation-
aware contexts: zero — the set is empty so the condition is never set.

Tests cover both the happy path (def each() through DefBootstrap fires
the runnable from inside the augmentation loop) and the gate (def
toString on an unrelated method name does not push script-this).

Restructure how @cancellation_aware augmentations pass the script
receiver so a future method-ref support layer can reuse
FunctionRef.withSyntheticScriptCapture (which prepends at position 0
of factoryMethodType) directly, without position arithmetic.

Augmentation methods now use the signature
  method(PainlessScript script, receiver, ...userArgs)
instead of the original Phase 1 layout (receiver, PainlessScript, ...).

Lookup:
- PainlessLookupBuilder.addPainlessMethod inserts PainlessScript at the
  beginning of the Java parameter list (before the receiver slot), not
  after, when @cancellation_aware fires.

Static call site:
- visitCall, for @cancellation_aware augmentations, folds the prefix
  expression into argumentNodes[0] of the InvokeCallNode instead of
  wrapping the call in a BinaryImplNode.  visitInvokeCall pushes
  loadThis() first, then the regular arg loop visits the prefix and
  user args in order.  The resulting stack at invokestatic is
  [scriptThis, receiver, ...userArgs] — direct, no swap.

Def call site:
- Bytecode shape is unchanged from Phase 2 (descriptor still receiver-
  first so PIC class dispatch keys off the actual receiver).  Def
  .lookupMethod now reconciles the script-first handle to the receiver-
  first descriptor with a new swapFirstTwoArguments helper that calls
  MethodHandles.permuteArguments on the resolved method handle.  When
  the resolved method doesn't carry @cancellation_aware (e.g. a user
  class shadowing the augmentation name) we still drop the scriptThis
  slot via dropArguments.

Augmentation.each: signature flipped to (PainlessScript, Iterable,
Consumer).

Tests: existing AugmentationCancellationTests (static + def variants)
all green.  Method-ref support for @cancellation_aware augmentations
is the next phase — the script-first layout means it can reuse
FunctionRef.withSyntheticScriptCapture without inventing a position-
aware variant.

A method ref like `l::each` to a @cancellation_aware augmentation now
threads the script receiver as a synthetic leading FunctionRef capture
via withSyntheticScriptCapture, matching the script-first augmentation
signature so LambdaBootstrap finds the cancellation-aware overload.

DefaultSemanticAnalysisPhase.visitFunctionRef detects when a bound
(`obj::method`) or unbound (`Type::method`) ref resolves to such an
augmentation and applies the synthetic capture plus
InstanceCapturingFunctionRef so the IR phase emits loadThis() at the
construction site. FunctionRef.create strips the leading PainlessScript
from delegateMethodType before the factory/delegate split so the rest
of the lambda linkage sees the user-visible shape.

Cover the paths that ensure the synthetic PainlessScript parameter is
only added where needed: non-cancellation contexts resolve the plain
each() overload (behavioral + bytecode), the two lookup-builder guards
reject misuse, and the def-dispatch fallback drops the script slot when
a shadowing receiver method is not cancellation-aware.

The descriptor-space and handle-space offsets are always equal: the
swap/dropArguments adaptation aligns the resolved handle's shape to
the call-site descriptor, so one scriptThisOffset serves both.

Cover the script-this push for cancellation_aware augmentations called
inside lambda bodies (static, def, def-encoded, and a loop+each static
lambda), and the loopless-lambda entry-time poll that underpins why
every lambda captures the script receiver.

The cancellation_aware each augmentation kept its own local poll
counter, restarting at the interval and ignoring the script's
$cancelPoll progress. Add a generated _pollCancellation() that
decrements and checks the shared field, reusing the same helper the
compiler emits inline, and call it from the augmentation so polling
is amortized across all script work. Drop the dead, local-counter
writeCancellationCheck that never honored the field.

Rename the @cancellation_aware annotation to the more general
@script_aware (it injects the PainlessScript; cancellation is just
the first use). Remove supportsCancellation from the lookup builder:
it now always binds the script-first augmentation overload and keeps
the annotation, leaving the activation decision to the compiler. The
compiler marks script-aware calls as using the script so enclosing
lambdas capture it in any context, and the def push is gated only on
the script-aware marker. Rename IRCMaybeNeedsScriptThis to
IRCScriptAware.

Remove the comments added by this branch from PainlessLookup and
PainlessLookupBuilder.

Replace the injectScript boolean with an int offset mirroring
augmentedParameterOffset when sizing the java type parameters.

Freeze the inner sets in build() alongside classesToDirectSubClasses
so the PainlessLookup constructor can use a plain Map.copyOf.

Add a regression test where the each consumer is a non-script-aware
method ref (no entry poll), so only the each augmentation's own poll
can fire cancellation, proving the l::each method reference threads the
script into the augmentation.

Remove the comments added by this branch from the four phase classes.

Shorten the IRCScriptAware, IRCCancellationCheck, and
IRCStaticCancellationCheck javadocs to one-liners matching the other
decoration comments.

In the generated _pollCancellation, dup the cancellation runnable for
the null check rather than storing and reloading it; the stored copy
still backs the later invoke when the counter reaches zero.

Static-cancellation lambdas skipped the legacy max-loop-counter setup,
so a loop had no bound when no cancellation runnable was set at
runtime. Set the counter up regardless, matching instance functions,
so the loop guard falls back to it when the runnable is null. Also
rename IRCCancellationCheck to IRCInstanceCancellationCheck to pair
with IRCStaticCancellationCheck.

Match the IRCInstanceCancellationCheck condition and pair with the
staticCancellation local.

Remove the writeLoopGuard and writeForEachLoopGuard wrappers and call
writeBranchedLoopGuard directly with the legacyForNonOptedIn flag at
each loop site.

Rename the writeBranchedLoopGuard parameter legacyForNonOptedIn to
legacy.

Load and cast the script instance once and dup it for the
getfield/putfield pair instead of loading it twice.

The script slot already holds the generated type at every cancellation
field access, so the helper's CHECKCAST was dead. Inline a plain ALOAD
and drop the helper.

Relocate the raw $cancelPoll decrement/runnable-invoke bytecode out of
DefaultIRTreeToASMBytesPhase and into MethodWriter#writeCancellationPoll,
alongside its analogue writeLoopCounter. The phase keeps writeBranchedLoopGuard,
which still resolves WriteScope variables and branches, then delegates the
raw emission downward. This puts scope/branch logic in the phase and bytecode
emission in MethodWriter, matching the existing layering.

Also add nested-call regression tests and YAML search-timeout tests for the
script-aware augmented each loop.

Fixes a checkstyle LineLength violation (146 > 140) on the
IRCStaticCancellationCheck javadoc that failed CI checkPart1.
Spotless does not wrap comments, so it passed local formatting
but checkstyleMain rejected it.