Fix: check ref mut mutability for method call arguments

[Dnreikronos]

Description

Method calls weren't checking whether immutable arguments were being passed to ref mut parameters. The check already existed for free and associated function calls in function_application.rs, but method_application.rs never had it, so violations slipped through.

This adds the same check to method calls and fixes the existing violations it surfaced. gather_mutability() now recurses through StructFieldAccess and TupleElemAccess prefixes and treats constants as immutable, so p.x, t.0, and const arguments get caught too. The contract-call path skips the implicit self when lining up argument and parameter indices.

The check turned up two real cases. Hasher::write was passing its immutable bytes param straight into Bytes::append(ref mut), and a reexport test passed an immutable hasher into a ref mut hash method. Both rebind to a mutable local first now.

A new should_fail test covers the immutable variable, struct field, tuple element, and constant cases, plus a mutable variable that should still pass.

Closes #7621

Checklist

• I have linked to any relevant issues.
• I have commented my code, particularly in hard-to-understand areas.
• I have updated the documentation where relevant (API docs, the reference, and the Sway book).
• If my change requires substantial documentation changes, I have requested support from the DevRel team
• I have added tests that prove my fix is effective or that my feature works.
• I have added (or requested a) parsing test in core_lang/tests/sway_parse, if relevant.
• I have added the necessary breaking and new feature labels where relevant.
• I have done my best to ensure that my PR adheres to the Fuel Labs Code Review Standards.
• I have requested a review from the relevant team or maintainers.

[cursor]

PR Summary

Medium Risk
Changes compile-time borrow/mutability rules for method calls and std Hasher::write; behavior is tightened with targeted e2e tests but may surface new errors in existing code.

Overview
Method calls now enforce the same immutable argument → ref mut parameter rule that free and associated functions already had, by running a shared check_arg_mutability during method application’s second argument pass (with correct arg/param alignment for contract calls, skipping self).

gather_mutability is extended so constants, struct fields (p.x), and tuple elements (t.0) on immutable bindings count as immutable, enabling those cases to be rejected at method sites.

Follow-up fixes: Hasher::write in std rebinds Bytes before append(ref mut), and a reexport test uses let mut hasher. A new should_fail e2e test covers the error cases and a passing mutable variable.

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

[codspeed-hq]

Merging this PR will improve performance by 11.01%

⚡ 1 improved benchmark
✅ 24 untouched benchmarks

Performance Changes

	Benchmark	BASE	HEAD	Efficiency
⚡	tokens_for_program	591.2 µs	532.5 µs	+11.01%

Tip

Curious why this is faster? Comment @codspeedbot explain why this is faster on this PR, or directly use the CodSpeed MCP with your agent.

---

_{Comparing Dnreikronos:fix/ref-mut-method-check (6367ec9) with master (ac933ff)}

[Dnreikronos]

bugbot run

[cursor]

✅ Bugbot reviewed your changes and found no new issues!

Comment @cursor review or bugbot run to trigger another review on this PR

^{Reviewed by Cursor Bugbot for commit 6367ec9. Configure here.}

[Dnreikronos]

@ironcev ready, and it picked up a small perf win on the way (codspeed has tokens_for_program about 11% faster). It runs the same immutable-arg into ref mut-param check on method calls that free and associated fns already had, and extends gather_mutability to cover consts, struct fields, and tuple elements. The bit to double-check is the arg/param alignment for contract calls, where it skips self.