Allow some cases of error union with error set payload

[wooster0]

I believe #12462 is what made it so that this no longer works:

fn fail(comptime fmt: []const u8, args: anytype) !error{CodegenFail} {
    oom();
    @import("std").debug.print(fmt, args);
    return error.CodegenFail;
}

fn oom() !void {
    return error.OutOfMemory;
}

test {
    _ = fail;
}

And while I can agree with that case, this also no longer works:

const CodegenFail = error{CodegenFail};
fn fail(comptime fmt: []const u8, args: anytype) !CodegenFail {
    oom();
    @import("std").debug.print(fmt, args);
    return @as(CodegenFail, error.CodegenFail);
}

fn oom() !void {
    return error.OutOfMemory;
}

test {
    _ = fail;
}

But I believe that at least this case is something that should be allowed.
Interestingly, this does work (note that the only difference is that the CodegenFail is "optional"):

const CodegenFail = error{CodegenFail};
fn fail(comptime fmt: []const u8, args: anytype) !?CodegenFail {
    oom();
    @import("std").debug.print(fmt, args);
    return @as(?CodegenFail, error.CodegenFail);
}

fn oom() !void {
    return error.OutOfMemory;
}

test {
    _ = fail;
}

But removing the two question marks:

x.zig:2:51: error: error union with payload of error set type 'error{CodegenFail}' not allowed
fn fail(comptime fmt: []const u8, args: anytype) !CodegenFail {
                                                  ^~~~~~~~~~~

I use this fail function to emit compile errors and it thus always returns an error which indicates that codegen failed so you can return with the result of fail and have it propagate correctly.
However, failing itself can also fail: it might run out of memory (in my case I'm allocating an error message).
Here's an example of its usage:

        return try fail("failed lowering unnamed constant: {}", .{err});

I think this communicates intent quite clearly: we want to fail so we try to fail and then if that succeeded we return with an error from the function and make it propagate.
But now I have to change it to return func.fail("", .{}) (no try) which I think doesn't communicate intent as well as before. Failing itself might fail so it might return error.OutOfMemory which has nothing to do with the normally only expected result of fail of error.CodegenFail.

Also, I would like to keep error.OutOfMemory inferred.