Convert a hand-rolled class to a dataclass without changing its equality semantics by accident

Convert the class below to a dataclass (or attrs, if you name why attrs fits better here). This must preserve exactly how instances are currently compared, hashed, and mutated — a dataclass conversion that changes equality or hashability semantics without saying so is a correctness bug, not a style improvement.

CLASS
class Point:\n    def __init__(self, x, y):\n        self.x = x\n        self.y = y\n    # no __eq__ defined

HOW INSTANCES ARE USED
Instances are stored in a set() to dedupe visited coordinates during a pathfinding search, and never mutated after creation.

MUTABILITY
Immutable — a Point is created once and never reassigned; a "moved" point is a new Point instance.

REQUIREMENTS
1. Before converting anything, state what the current class's __eq__, __hash__, and __repr__ actually do today — if it doesn't define __eq__, say explicitly that it currently uses identity comparison (is), because @dataclass generates a field-by-field __eq__ by default, which is a real behavior change if the code anywhere currently relies on identity.
2. Set frozen= based on Immutable — a Point is created once and never reassigned; a "moved" point is a new Point instance., not by default. If instances must be usable as dict keys or set members, they need to be hashable, which requires either frozen=True (dataclass then auto-generates a compatible __hash__) or an explicit eq=False with a hand-written __hash__ — pick correctly and say why, don't leave a mutable dataclass with eq=True, which is unhashable by default and will raise TypeError the first time someone tries to put an instance in a set.
3. Use field(default_factory=...) for any mutable default (a list, dict, or set attribute) — never a bare mutable default value, which dataclass itself explicitly forbids at class-definition time and will raise ValueError if attempted, unlike a plain class where the same mistake fails silently.
4. If the original class has any custom method beyond __init__/__eq__/__repr__/__hash__ (a computed property, a validation method, a classmethod constructor), keep it as-is on the dataclass — a dataclass is still a normal class, and business logic doesn't disappear just because field boilerplate did.
5. If Instances are stored in a set() to dedupe visited coordinates during a pathfinding search, and never mutated after creation. shows instances being mutated after construction in a way that's incompatible with the mutability decision in step 2, flag the conflict explicitly rather than silently picking one side.
6. If Subclassed once, by GridPoint(Point), which adds a "layer" field with no default of its own. shows this class is subclassed elsewhere, check field ordering carefully: a dataclass field with a default value cannot be followed by a subclass field without one, so converting a base class to a dataclass can break an existing subclass's field ordering in a way that only surfaces as a TypeError at class-definition time in a completely different file.
7. Consider whether slots=True is worth adding given how many instances Instances are stored in a set() to dedupe visited coordinates during a pathfinding search, and never mutated after creation. implies will exist at once — it removes each instance's __dict__ in favor of fixed storage, which matters for memory at scale but breaks dynamic attribute assignment, so state explicitly whether that trade-off fits here rather than defaulting to it or skipping it without comment.

OUTPUT FORMAT
1. What the original class's equality/hash/repr behavior actually was.
2. The converted dataclass.
3. One sentence confirming whether instances remain usable exactly where Instances are stored in a set() to dedupe visited coordinates during a pathfinding search, and never mutated after creation. needs them (as dict keys, in a set, appended to a list and mutated later, etc.), or naming the specific conflict if one exists.
4. One sentence on whether Subclassed once, by GridPoint(Point), which adds a "layer" field with no default of its own. introduces any field-ordering risk, and whether slots=True was worth adding.