Sema: rewrite peer type resolution

[mlugg]

The existing logic for peer type resolution was quite convoluted and buggy. This rewrite makes it much more resilient, readable, and extensible. The algorithm works by first iterating over the types to select a "strategy", then applying that strategy, possibly applying peer resolution recursively.

Several new tests have been added to cover cases which the old logic did not correctly handle.

Resolves: #15138
Resolves: #15644
Resolves: #15693
Resolves: #15709
Resolves: #15752

[mlugg]

I ran each of the following tests 5 times on my system (Ryzen 7 1800x @ 3.6 GHz; 16GB DDR4 @ 2133 MT/s; Void Linux).
The system was under minimal other load. All tests were run with a clean cache.

Test	Old	New	% change
Build behaviour tests	11.5s	11.2s	-3%
Build compiler (only-c)	26.1s	25.4s	-3% (note: high variability)
Build ptr_stress.zig	4.45s	4.54s	+2%

ptr_stress.zig is a little test program I wrote with the intention of running PTR with a large number of peers.

ptr_stress.zig

//! This is a nonsense program meant to hit Peer Type Resolution code in expensive ways.
//! Intended for benchmarking the compiler on PTR-heavy code.

const std = @import("std");

fn ptrThing(comptime seed: u32) void {
    var x: u10 = undefined;

    @setEvalBranchQuota(100_000);

    const res = switch (x) {
        // We need these because old PTR is order-dependent
        // (and also crashes if we include an error set below)
        0 => @as(u64, 0),
        1 => error.Foo,
        inline else => |x_ct| blk: {
            const ResultType: type = switch ((seed *% @as(u32, x_ct)) % 6) {
                0 => @TypeOf(null),
                1 => ?u64,
                2 => u64,
                3 => u32,
                4 => noreturn,
                5 => @TypeOf(undefined),
                else => unreachable,
            };

            if (ResultType == noreturn) {
                break :blk while (true) {};
            } else {
                break :blk @as(ResultType, undefined);
            }
        },
    };

    if (@TypeOf(res) != error{Foo}!?u64) {
        @compileError(std.fmt.comptimePrint("Unexpected result type: {}", .{@TypeOf(res)}));
    }
}

pub fn main() void {
    ptrThing(747079);
    ptrThing(723898);
    ptrThing(69178);
    ptrThing(202813);
    ptrThing(110022);
}

Of course, this change won't actually improve performance for anything - you could get more accurate
numbers here by profiling under more controlled conditions and doing far more repeats (manually doing
them becomes tedious quickly). But it seems that the impact this change has on performance is negligible.

[andrewrk]

Thank you for doing this work, and for providing perf measurements.

I have requested changes based on the behavior changes alone; I have not looked at Sema.zig yet.

Also please don't mark this as closing #9917 since there is a translate-c bug in that issue as well as a peer type resolution bug.