Add RustyHash adapter and include try.hpp in parity runner

RustyHash<K> (include/rusty/hashmap.hpp):
- Generic hash adapter for rusty::HashMap default hash parameter
- Uses std::hash<K> when available (SFINAE specialization)
- Falls back to K::hash() method (transpiled Rust #[derive(Hash)])
- Last resort: FNV hash of raw bytes
- Fixes: std::hash<ArrayString<16>>::~hash() deleted error

HashMap default hash changed from std::hash<K> to RustyHash<K>.
This lets transpiled types with .hash() methods work as HashMap keys
without requiring explicit std::hash specializations.

Runner generation (transpiler/src/main.rs):
- Added #include <rusty/try.hpp> for RUSTY_TRY/RUSTY_CO_TRY macros
- Fixes: RUSTY_TRY not declared in scope error

716 transpiler tests + 19 C++ io tests, all passing.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: shuaimu

include/rusty/hashmap.hpp

@@ -10,6 +10,39 @@
 #include "option.hpp"
 #include "vec.hpp"
 
+// Generic hash adapter: uses std::hash<K> if available, otherwise falls back
+// to calling K::hash() method (as generated by Rust's #[derive(Hash)]).
+// This bridges transpiled Rust types (which have .hash() methods) with C++
+// hash containers that expect std::hash<K>.
+template<typename K, typename = void>
+struct RustyHash {
+    // Fallback: call the type's .hash() method if it has one
+    size_t operator()(const K& key) const {
+        size_t state = 0;
+        if constexpr (requires { key.hash(state); }) {
+            key.hash(state);
+            return state;
+        } else {
+            // Last resort: hash the raw bytes
+            const auto* bytes = reinterpret_cast<const unsigned char*>(&key);
+            size_t h = 14695981039346656037ULL;
+            for (size_t i = 0; i < sizeof(K); ++i) {
+                h ^= bytes[i];
+                h *= 1099511628211ULL;
+            }
+            return h;
+        }
+    }
+};
+
+// Specialization: if std::hash<K> is valid, use it
+template<typename K>
+struct RustyHash<K, std::void_t<decltype(std::hash<K>{}(std::declval<K>()))>> {
+    size_t operator()(const K& key) const {
+        return std::hash<K>{}(key);
+    }
+};
+
 // Swiss Table HashMap - High-performance hash table based on Google's SwissTable/Abseil
 // and Rust's HashMap implementation
 //
@@ -141,7 +174,7 @@ struct ProbeSeq {
     }
 };
 
-template <typename K, typename V, typename Hash = std::hash<K>, typename KeyEqual = std::equal_to<K>>
+template <typename K, typename V, typename Hash = RustyHash<K>, typename KeyEqual = std::equal_to<K>>
 class HashMap {
 private:
     // Bucket structure

transpiler/src/main.rs

@@ -1314,7 +1314,7 @@ fn run_parity_test(args: &ParityTestArgs) -> Result<(), String> {
         runner_src.push_str("#include <iostream>\n#include <cassert>\n#include <vector>\n");
         runner_src.push_str("#include <functional>\n#include <span>\n");
         runner_src.push_str("#include <rusty/rusty.hpp>\n");
-        runner_src.push_str("#include <rusty/io.hpp>\n#include <rusty/array.hpp>\n\n");
+        runner_src.push_str("#include <rusty/io.hpp>\n#include <rusty/array.hpp>\n#include <rusty/try.hpp>\n\n");
         runner_src.push_str("// Overloaded visitor helper\n");
         runner_src.push_str(
             "template<class... Ts> struct overloaded : Ts... { using Ts::operator()...; };\n",