Clear hoisted locals when disposing iterator and async-iterator state machines

[jcouv]

Fixes #75666

Background

We already have logic to clear unmanaged hoisted locals when we exit scopes. But that logic has a number of limitations:

1. we don't clear top-level locals on normal exit
2. we don't clear any locals on yield break
3. we don't clear any locals on early exit (from yield return, ie. foreach (var i in coll) { break; })
4. we don't clear any locals on throw

static IEnumerable<int> Produce()
{
    {
        string hoistedNestedLocal = "";
        // existing clearing logic doesn't work for:
        // `yield break`
        // `yield return` and the caller breaks `foreach (var i in coll) { break; }`
        // `throw`
    }

    string hoistedTopLevelLocal = "";
    // existing clearing local doesn't work for:
    // normal exit (because a `yield break` is injected, see `FlowAnalysisPass.AppendImplicitReturn`, so the cleanup is added after a `yield break`)
    // `yield break`
    // `yield return` and the caller breaks `foreach (var i in coll) { break; }`
    // `throw`
}

So the current design only works for nested locals on normal exit from their scope.

Change

This PR clears the hoisted fields for all the locals (top-level and nested) in the part of the code that handles disposal: in Dispose method for iterators and at the end of MoveNext for async-iterators.
There is no need to add such clearing for async state machines, as it is non-trivial for a user to get a direct reference to those.

The proposed design fixes scenarios 1, 2, 3, and most of 4 (a throw during disposal still results in uncleared state).
This remains "best effort", as we don't want to add the overhead of an additional try/finally to handle that last scenario.

Look at the diff between commit 1 (baseline) and commit 2 (code change) to see the expectedOutput and IL changes.