…ransaction

`check_transaction` now assembles and returns the
`TransactionEnvironment` instead of an ad-hoc tuple, consuming the
`IntrinsicGasCost` from `validate_transaction` and calling
`allocate_execution_gas` for the regular/state gas split. The
access-list prewarming and authorizations move in with it, and the
transactions-trie write moves after validation -- a transaction that
fails validation aborts the block, so recording it first was an
unobservable mutation.

The chain-id check stays in `process_transaction` before
`recover_sender`: for a legacy transaction `chain_id` also validates the
`v` value that `recover_sender` then relies on, so it cannot move into
`check_transaction` (which runs after `recover_sender`).

No behavior change (Amsterdam fixtures fill byte-identically).

Message and Evm were two mutable halves of one frame: the warm sets were
aliased, resolve_dispatch double-wrote the code, and the top frame
mutated the supposedly immutable message. Fold Message's call parameters
onto the Evm dataclass so callers construct child frames directly and the
Message->Evm hand-off disappears.

- The two entry grants (entry_gas, state_gas_grant) live on the
  GasMeter, which becomes self-describing: tx_state_gas_used and
  restore_state_gas_to_entry no longer take the grant as a parameter.
- MessageCallOutput is retired; process_message_call returns the
  finished frame and normalizes error results on it.
- prepare_message becomes create_top_level_evm in fork.py and
  utils/message.py is deleted; system transactions build the frame
  inline.
- The unreachable stack-depth guard moves inside process_message's try,
  so a fire is settled as the exceptional halt it is rather than
  escaping the frame.
- The EIP-3155 and opcode-count tracers resolve the message-scoped
  fields via getattr(evm, "message", evm), keeping older forks traced
  through the same protocols; the Evm trace protocol drops its stale
  `message` member.

No behavior change: the full Amsterdam suite (52,812 cases) fills
byte-identically; ruff and mypy clean.

…usion

Drop the dead TransactionEnvironment.recipient/.value fields (no
readers), and hoist the transaction's resolved blob fee onto the
environment as blob_gas_fee, computed once in check_transaction at the
current blob gas price. Extract the upfront sender debit into a
charge_sender helper that reads that fee, and derive the top frame's
create address from tx.nonce directly rather than reading the
already-incremented sender nonce back.

Byte-identical on Amsterdam fixtures.

Move the depth-0 preparation block -- EIP-7702 delegation application
and dispatch resolution -- out of process_message and up into
process_message_call, where it runs once before the create-vs-call
dispatch. process_message now executes only the code of whichever
frame it is given, top-level or child.

Byte-identical on the full Amsterdam fixture set.

Split process_message_call into ready_top_level_evm (apply
authorizations and resolve dispatch) and run_top_level_evm (dispatch
to create or call, then close out). Both mutate the frame in place and
are called as a pair by process_transaction and
process_unchecked_system_transaction. Everything transaction-scoped --
sender charging, settlement, receipt assembly -- stays outside the
pair, so a future frame loop can call it once per top-level frame.

Byte-identical on Amsterdam fixtures.

Pass the top frame's finished GasMeter to settle_transaction_gas and
derive execution gas used, refund counter, and net state gas from it
inside the function, rather than threading each figure through the
call. The pre-refund usage is now the intrinsic regular cost plus the
execution gas the frame consumed across both dimensions.

Byte-identical on the full Amsterdam fixture set.

Move the two post-settlement fee transfers -- the unspent-gas refund
and the coinbase priority fee -- into disburse_gas_fees, parameterized
on the payer that receives the refund (the sender on the standard
path). Pairs with charge_sender: one fronts the maximum fee at
inclusion, the other returns the remainder and pays the miner.

Byte-identical on Amsterdam fixtures.