(opt): reprocess replaced block ends for inlining

[orizi]

The interleaved inlining/const-folding pass scans a block's statements for
inlinable calls before const folding visits the block end. When that visit
replaces the end it may append new statements (e.g. rewriting a match on
x - 1 into a call to an inc/dec function), which nothing scanned again, so
such calls were only inlined if the containing function was itself later
inlined into a caller - otherwise they survived as un-inlined calls (see the
removed u32_inc call in the function_generator golden).

Reprocess the statements appended by a block-end replacement, similar to the
reprocessing of replaced statements. This slightly shrinks generated code
(e.g. the libfuncs_coverage contract).

[reviewable-StarkWare]

This change is 

[orizi]

• (opt): skip specializing calls that would be inlined #10350
• (opt): fold struct destructure of a constant into member constants #10357
• (opt): reprocess replaced block ends for inlining #10349 👈 (View in Graphite)
• (opt): memoize function code size estimation #10348
• main

This stack of pull requests is managed by Graphite. Learn more about stacking.

[cursor]

PR Summary

Medium Risk
Touches core lowering/inlining and const-folding interaction; wrong indexing or double visit_block_end could mis-inline or corrupt CFG, though behavior is covered by updated compiler golden tests.

Overview
Fixes a gap in the interleaved inlining + const-folding pass: inlinable calls were only searched in the block’s original statements, so when const folding rewrote a block end and prepended new calls (e.g. turning x - 1 into an inc/dec call), those calls were skipped unless the whole function was later inlined elsewhere.

The inline loop now invokes visit_block_end mid-scan when it reaches the end of the statement list, uses the returned prepend count to advance the index, and keeps scanning—including those newly appended statements—for should_inline. Const folding’s visit_block_end returns how many statements were spliced in, relaxes reachability asserts when a match end is revisited after inlining moves it to a continuation block, and runs try_specialize_call on inc/dec calls inserted during enum block-end lowering.

Golden Sierra output and Starknet compiled-class hashes/bytecode update accordingly (e.g. u32_inc replaced by bounded-int paths in generator tests; slightly smaller libfuncs coverage contract).

^{Reviewed by Cursor Bugbot for commit 1f2e292. Bugbot is set up for automated code reviews on this repo. Configure here.}

[TomerStarkware]

@TomerStarkware reviewed 7 files and all commit messages, and made 1 comment.
Reviewable status: complete! all files reviewed, all discussions resolved (waiting on eytan-starkware).