Fix ICE when data section exceeds 2^12 words

[Dnreikronos]

Summary

Closes #7612.

• Root cause: realize_load() panicked for copy-type data section offsets exceeding 12-bit LW/LB immediate range (4095 words / 32KB). Any program with a data section larger than this ICE'd during codegen.
• Fix: Three-tier offset strategy for copy-type loads:
  • ≤12 bits → single LW/LB with immediate offset (unchanged behavior)
  • >12 bits, ≤18 bits → MOVI + ADD $ds + LW/LB (3 instructions, uses dest register as scratch)
  • >18 bits → panic with clear message (data section ~256KB limit)
• Size estimation: Updated op_size_in_bytes (finalized_asm.rs) and instruction_size_not_far_jump (allocated_abstract_instruction_set.rs) to return correct instruction counts for both paths, so jump offsets remain aligned.
• Helper: Added DataSection::size_in_bytes() for pre-pointer-insertion size snapshots.
• Regression test: large_data_section e2e test creates 4200+ distinct u64 entries (values >262143 to bypass MOVI inlining), verifying correct codegen via checksum.

Test plan

• cargo check -p sway-core passes
• large_data_section test passes — exercises the >12-bit copy-type offset path
• All 333 should_pass/language e2e tests pass with 0 failures
• CI full suite

[fuel-cla-bot]

Thanks for the contribution! Before we can merge this, we need @Dnreikronos to sign the Fuel Labs Contributor License Agreement.

[cursor]

PR Summary

High Risk
Touches core Fuel bytecode emission, jump/label offset sizing, and PC-relative pointer math; mis-sizing would cause subtle wrong-code bugs, not just compile failures.

Overview
Fixes compiler ICEs when static data section offsets exceed the 12-bit immediate range of LW/LB, and keeps bytecode size estimates aligned with the expanded instruction sequences.

Copy-type loads in realize_load now use a single LW/LB when the offset fits in 12 bits; otherwise MOVI + ADD with the data-section register + load (up to an 18-bit byte offset, with a clear failure beyond that). Non-copy loads rely on pointers pre-inserted during to_bytecode_mut, keyed by (source DataId, load-site offset) instead of only the computed pointer value, so multiple loads of the same data at different sites stay correct.

Sizing and layout: op_size_in_bytes and instruction_size_not_far_jump account for the larger encodings (including worst-case pointer slots appended to non-configurables). Pointer pre-insertion predicts inner load size from the last pointer’s word offset and adjusts the PC-relative correction accordingly. DataSection::non_configurables_size_in_bytes() supports sizing before pointers are appended.

Adds an e2e large_data_section script that forces a >32KB data section and checks a fixed sum at runtime.

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

[cursor]

Cursor Bugbot has reviewed your changes and found 2 potential issues.

^{❌ Bugbot Autofix is OFF. To automatically fix reported issues with cloud agents, enable autofix in the Cursor dashboard.}

^{Reviewed by Cursor Bugbot for commit 4d3f0f9. Configure here.}