Add support for std::hash in wrap-hash directive

This commit adds support for using C++ std::hash<T> specializations
directly in Python bindings via the wrap-hash directive.

Changes:
- Add `cpp_hash` declaration (aliased from std::hash) in generated code
- Support `# wrap-hash:\n#  std` syntax to automatically use std::hash<T>
- Maintain backward compatibility with existing expression-based wrap-hash

Usage in .pxd files:
```
cdef cppclass MyClass:
    # wrap-hash:
    #  std
```

This generates:
```python
def __hash__(self):
    cdef cpp_hash[MyClass] hasher
    return hasher(deref(self.inst.get()))
```

The `cpp_hash` name is used instead of `hash` to avoid conflicts with
Python's built-in hash() function.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: timosachsenberg

autowrap/CodeGenerator.py

@@ -671,18 +671,33 @@ def create_wrapper_for_class(self, r_class: ResolvedClass, out_codes: CodeDict)
             )
 
         if len(r_class.wrap_hash) != 0:
-            class_code.add(
-                """
+            hash_expr = r_class.wrap_hash[0].strip()
+            # If hash expression is "std" or empty, use std::hash<T>
+            if hash_expr.lower() == "std" or not hash_expr:
+                class_code.add(
+                    """
+                            |
+                            |    def __hash__(self):
+                            |      # Uses C++ std::hash<$cpp_name> specialization
+                            |      cdef cpp_hash[$cy_type] hasher
+                            |      return hasher(deref(self.inst.get()))
+                            |
+                            """,
+                    locals(),
+                )
+            else:
+                class_code.add(
+                    """
                             |
                             |    def __hash__(self):
                             |      # The only required property is that objects which compare equal have
                             |      # the same hash value:
                             |      return hash(deref(self.inst.get()).%s )
                             |
                             """
-                % r_class.wrap_hash[0],
-                locals(),
-            )
+                    % hash_expr,
+                    locals(),
+                )
 
         if len(r_class.wrap_len) != 0:
             class_code.add(
@@ -2088,6 +2103,15 @@ def create_default_cimports(self):
                    |from  libcpp.memory   cimport shared_ptr
                    """
         )
+        # Add std::hash declaration for wrap-hash support (named cpp_hash to avoid conflict with Python hash)
+        code.add(
+            """
+                   |cdef extern from "<functional>" namespace "std" nogil:
+                   |    cdef cppclass cpp_hash "std::hash" [T]:
+                   |        cpp_hash() except +
+                   |        size_t operator()(const T&) except +
+                   """
+        )
         if self.include_numpy:
             code.add(
                 """