allow equality operator for packed structs

[andrewrk]

const std = @import("std");
const expect = std.testing.expect;

test "packed struct equality" {
    const S = packed struct {
        a: u4,
        b: u4,
    };
    const x: S = .{ .a = 1, .b = 2 };
    const y: S = .{ .b = 2, .a = 1 };
    try expect(x == y);
}

test.zig:11:18: error: operator == not allowed for type 'test.test.packed struct equality.S'
    try expect(x == y);
               ~~^~~~
test.zig:5:22: note: struct declared here
    const S = packed struct {
              ~~~~~~~^~~~~~

This test should pass, for the same reason that equality is allowed for enums.

[T-727]

In my opinion it would be better to implement @backingInt and compare the result of that.
reasoning:
A) clear intent
B) no operator special case for what is a sub-type of structs
C) If both features are accepted we have too many ways to do the same

[rohlem]

C) If both features are accepted we have too many ways to do the same

@T-727 I disagree here: If Zig allows you to write both @backingInt(a) == @backingInt(b) and a == b, then the latter still is the more obvious way to do things.
Additionally, I assume that the proposed equality is only defined if @TypeOf(a) == @TypeOf(b) (also asked this in #21679 (comment)) -
in that case @backingInt loses that type safety and is clearly inferior if both would be valid.

That in turn negates your point A) - the intent of a == b is clearer,
because the intent behind @backingInt(a) == @backingInt(b) may well be to compare the backing integer / in-memory representation of possibly-distinct types.
That may however still be the intent for certain use cases, making the ability to express it still valuable.