fix(semantic): narrow return-type mismatch span to the value-producing expression - #9931

Summary

The WrongReturnType diagnostic now points to the actual value-producing expression instead of the return type annotation in the function signature.

A new helper function value_producer_stable_ptr is introduced in compute.rs that drills through blocks (to their tail), match expressions (to the first non-never arm), and if expressions (to the first non-never branch) to locate the concrete sub-expression responsible for producing the returned value. This pointer is used as the diagnostic span instead of the return type clause in the signature.

Type of change

Please check one:

• Bug fix (fixes incorrect behavior)

Why is this change needed?

Previously, when a function returned a value of the wrong type, the error diagnostic highlighted the return type annotation in the function signature (e.g., -> u8). This was often unhelpful because the annotation itself is correct — the problem is the expression that actually produces the value. Pointing at the return type annotation forced developers to manually trace which expression was at fault.

What was the behavior or documentation before?

The E2042: Unexpected return type diagnostic pointed to the return type clause in the function signature, for example:

error[E2042]: Unexpected return type. Expected: "()", found: "core::integer::u8".
 --> lib.cairo:1:13
fn foo() -> () {
            ^^

What is the behavior or documentation after?

The diagnostic now points directly to the offending value-producing expression:

error[E2042]: Unexpected return type. Expected: "()", found: "core::integer::u8".
 --> lib.cairo:2:5
    4_u8
    ^^^^

For compound expressions like blocks, matches, and ifs, the diagnostic drills into the relevant sub-expression rather than spanning the entire function body.

Related issue or discussion (if any)

Fixes #6486

Additional context

For empty function bodies (no tail expression), the diagnostic falls back to pointing at the closing } of the block, which correctly indicates that a value is missing.