fix(fuzz): Always introduce a local binding before match

[aakoshh]

Description

Problem*

Resolves #9862

Summary*

Fixes the AST fuzzer Match generation to always introduce a local let binding to match on, even when we are using a local variable already.

Additional Context

The Match::variable_to_match field contains a LocalId, not an Expression or Ident. The actual monomorphizer always introduced a let internal variable = <expr>; variable. At the time I didn't do this in the fuzzer, probably to make it easier to use the printed AST as Noir for reproducing failures. I restricted gen_match to pick variables which have LocalId, or a global variable, in which case it did introduce an indirection via let binding.

The problem that seemingly never came up before, was that the ownership analysis looks for Ident::ident_id in the last_uses module, and Match::variable_to_match doesn't have that, only a LocalId, so it did not count as use. This resulted in a code such as the following not emitting a .clone():

let a = (1, [2,3]);
foo(a.0);
match a {
  (_, xs) => match a {
    (_, xs) => xs
  }
}

Because match a didn't count as a use for a, foo(a.0) was considered the last use of a and wasn't replaced with foo(a.0.clone()).

Initially I thought we could replace Match::variable_to_match with an Ident, and then change last_uses::LastUseContext::track_variables_in_match to analyse it, however that doesn't work, because in ownership::Context::handle_match we have to be able to mutate an Expression in clone_expr when it's not the last use. That is, the first match a above has to become match a.clone(), but it can't, because at variable_to_match would be an Ident, not an Expression, and it's too late to make a Let binding in the parent at that point.

Instead the fuzzer now unconditionally introduces a new binding:

fn main(mut a: pub ([bool; 3], Field, bool, bool, bool), b: pub bool, c: pub ([bool; 3], bool, bool)) -> return_data [bool; 3] {
    let mut ctx_limit: u32 = 25_u32;
    let p = unsafe { func_1_proxy(a.0, c.0[0_u32], c, ctx_limit) };
    let d = a;
    match d {
        (item_e, item_f, item_g, item_h, item_i) => {
            let j = a;
            match j {
                (item_k, item_l, item_m, item_n, item_o) => item_k,
            }
        },
    }
}

which in raw format becomes:

unconstrained fn main$f0(mut a$l0: pub ([bool; 3], Field, bool, bool, bool), b$l1: pub bool, c$l2: pub ([bool; 3], bool, bool)) -> return_data [bool; 3] {
    let mut ctx_limit$l16 = 25;
    let p$l15 = func_1_proxy$f2(a$l0.0.clone(), c$l2.0[0], c$l2, ctx_limit$l16);
    let d$l3 = a$l0.clone();
    match $3 {
        ($4, $5, $6, $7, $8) => {
            let j$l9 = a$l0;
            match $9 {
                ($10, $11, $12, $13, $14) => item_k$l10,
            }
        },
    }
}

Documentation*

Check one:

• No documentation needed.
• Documentation included in this PR.
• [For Experimental Features] Documentation to be submitted in a separate PR.

PR Checklist*

• I have tested the changes locally.
• I have formatted the changes with Prettier and/or cargo fmt on default settings.