Revert "fix: avoid Python 3.9 dataclass unsafe_hash inheritance error"

This reverts commit 62162d2.
Thats was not the problem.

---

Current issue:
```
  tests/test_cli_args.py:8: in <module>
      import schema_salad.main as cli_parser
  schema_salad/main.py:16: in <module>
      ???
  schema_salad/codegen.py:18: in <module>
      ???
  schema_salad/rust_codegen.py:266: in <module>
      ???
  E   AttributeError: attribute '__dict__' of 'type' objects is not
writable
```

Author: giuseppe998e

schema_salad/rust_codegen.py

@@ -175,15 +175,12 @@ class RustMeta(ABC):
     pass
 
 
-@dataclass  # ASSERT: Immutable class
+@dataclass(unsafe_hash=True)  # ASSERT: Immutable class
 class RustAttribute:
     """Represents a Rust attribute (e.g., `#[derive(Debug)]`)."""
 
     meta: RustMeta
 
-    def __hash__(self) -> int:
-        return hash(self.meta)
-
     def __str__(self) -> str:
         return f"#[{str(self.meta)}]"
 
@@ -196,16 +193,13 @@ def __str__(self) -> str:
 RustGenericsMut = MutableSequence[Union[RustLifetime, "RustPath"]]  # alias
 
 
-@dataclass  # ASSERT: Immutable class
+@dataclass(unsafe_hash=True)  # ASSERT: Immutable class
 class RustPathSegment:
     """Represents a segment in a Rust path with optional generics."""
 
     ident: RustIdent
     generics: RustGenerics = dataclasses.field(default_factory=tuple)
 
-    def __hash__(self) -> int:
-        return hash((self.ident, self.generics))
-
     REX: ClassVar[Pattern[str]] = re.compile(
         r"^([a-zA-Z_]\w*)(?:<([ \w\t,'<>]+)>)?$"
     )  # Using `re.Pattern[str]` raise CI build errors
@@ -262,17 +256,14 @@ def parse_generics_string(value_generics: str) -> RustGenerics:
 RustPathSegmentsMut = MutableSequence[RustPathSegment]  # alias
 
 
-@dataclass  # ASSERT: Immutable class
+@dataclass(unsafe_hash=True)  # ASSERT: Immutable class
 class RustPath(RustMeta):
     """Represents a complete Rust path (e.g., `::std::vec::Vec<T>`)."""
 
     # ASSERT: Never initialized with an empty sequence
     segments: RustPathSegments
     leading_colon: bool = False
 
-    def __hash__(self) -> int:
-        return hash((self.segments, self.leading_colon))
-
     def __truediv__(self, other: Union["RustPath", RustPathSegment]) -> "RustPath":
         if self.segments[-1].generics:
             raise ValueError("Cannot chain to a RustPath with generics.")
@@ -313,16 +304,13 @@ def from_str(cls, value: str) -> "RustPath":
         return cls(segments=tuple(segments), leading_colon=leading_colon)
 
 
-@dataclass  # ASSERT: Immutable class
+@dataclass(unsafe_hash=True)  # ASSERT: Immutable class
 class RustTypeTuple(RustType):
     """Represents a Rust tuple type (e.g., `(T, U)`)."""
 
     # ASSERT: Never initialized with an empty sequence
     types: Sequence[RustPath]
 
-    def __hash__(self) -> int:
-        return hash(self.types)
-
     def __str__(self) -> str:
         types_str = ", ".join(str(ty) for ty in self.types)
         return f"({types_str})"