…ion (dotnet#96647)

Delete the old loop canonicalization. Implement canonicalization on new loops;
the only canonicalization done is creation of preheaders.

Diffs expected, in particular due to ambiguous cases where the old loop finding
identifies more loops than the new loop finding. The old loop finding would then
canonicalize these extra loops in such a way that new loop finding also found
them. That is, the old pipeline:

```
old loop finding -> old loop canonicalization -> new loop finding
```

would result in more loops found than

```
old loop finding -> new loop finding -> new loop canonicalization
```

An example of a program where it is ambiguous how many loops it contains based
only on the flow graph is the following:

```csharp
[MethodImpl(MethodImplOptions.NoInlining)]
private static void Foo(int n)
{
    n *= 2;

    do
    {
        if (n == 3)
        {
            n -= 2;
            continue;
        }

        if (n == 4)
        {
            n -= 3;
            continue;
        }

        if (n == 5)
        {
            n -= 4;
            continue;
        }

        n--;
    } while (n > 0);
}
```

Old loop finding finds 4 loops in this program, while new loop finding finds 1
loop. The backedges (`continue` statements) can either be seen as nested loop
backedges or as backedges to the outer loop). Here is another, opposite case:

```csharp
[MethodImpl(MethodImplOptions.NoInlining)]
private static void Foo(int n)
{
    n *= 2;
    do
    {
        do
        {
            n *= 3;
        } while (n < 5);

        n -= 10;
    } while (n != 0);
}
```

Old loop finding finds 2 loops but new loop finding finds 1 loop.

The differences in loop identification lead to the diffs. Instead of trying to
proactively handle them, we are going to see if the perf lab finds any examples
that we can gain insight on. One avenue to explore may be to use PGO information
to figure out what may be nested loops vs what may just be backedges.