identity: Use xxHash in hashstructure (note)

```
name                 old time/op    new time/op    delta
HashString/n28-10       133ns ± 9%     107ns ±10%  -19.58%  (p=0.029 n=4+4)
HashString/n112-10      243ns ± 5%     121ns ± 4%  -50.08%  (p=0.029 n=4+4)
HashString/n448-10      698ns ± 3%     174ns ± 5%  -75.02%  (p=0.029 n=4+4)
HashString/n1792-10    2.58µs ± 4%    0.38µs ± 4%  -85.11%  (p=0.029 n=4+4)
HashString/n7168-10    10.0µs ± 3%     1.3µs ± 4%  -86.91%  (p=0.029 n=4+4)

name                 old alloc/op   new alloc/op   delta
HashString/n28-10       80.0B ± 0%     72.0B ± 0%  -10.00%  (p=0.029 n=4+4)
HashString/n112-10       160B ± 0%      152B ± 0%   -5.00%  (p=0.029 n=4+4)
HashString/n448-10       496B ± 0%      488B ± 0%   -1.61%  (p=0.029 n=4+4)
HashString/n1792-10    1.84kB ± 0%    1.83kB ± 0%   -0.43%  (p=0.029 n=4+4)
HashString/n7168-10    8.24kB ± 0%    8.23kB ± 0%   -0.06%  (p=0.029 n=4+4)

name                 old allocs/op  new allocs/op  delta
HashString/n28-10        4.00 ± 0%      3.00 ± 0%  -25.00%  (p=0.029 n=4+4)
HashString/n112-10       4.00 ± 0%      3.00 ± 0%  -25.00%  (p=0.029 n=4+4)
HashString/n448-10       4.00 ± 0%      3.00 ± 0%  -25.00%  (p=0.029 n=4+4)
HashString/n1792-10      4.00 ± 0%      3.00 ± 0%  -25.00%  (p=0.029 n=4+4)
HashString/n7168-10      4.00 ± 0%      3.00 ± 0%  -25.00%  (p=0.029 n=4+4)
```

2 files changed, 26 insertions, 4 deletions

diff --git a/identity/identityhash.go b/identity/identityhash.go
index 70371e567..7d3b83a0d 100644
--- a/identity/identityhash.go
+++ b/identity/identityhash.go
@@ -15,7 +15,9 @@ package identity
 
 import (
 	"strconv"
+	"sync"
 
+	"github.com/cespare/xxhash/v2"
 	"github.com/mitchellh/hashstructure/v2"
 )
 
@@ -28,6 +30,23 @@ func HashString(vs ...any) string {
 	return strconv.FormatUint(hash, 10)
 }
 
+var hashOptsPool = sync.Pool{
+	New: func() any {
+		return &hashstructure.HashOptions{
+			Hasher: xxhash.New(),
+		}
+	},
+}
+
+func getHashOpts() *hashstructure.HashOptions {
+	return hashOptsPool.Get().(*hashstructure.HashOptions)
+}
+
+func putHashOpts(opts *hashstructure.HashOptions) {
+	opts.Hasher.Reset()
+	hashOptsPool.Put(opts)
+}
+
 // HashUint64 returns a hash from the given elements.
 // It will panic if the hash cannot be calculated.
 // Note that this hash should be used primarily for identity, not for change detection as
@@ -44,7 +63,10 @@ func HashUint64(vs ...any) uint64 {
 		o = elements
 	}
 
-	hash, err := hashstructure.Hash(o, hashstructure.FormatV2, nil)
+	hashOpts := getHashOpts()
+	defer putHashOpts(hashOpts)
+
+	hash, err := hashstructure.Hash(o, hashstructure.FormatV2, hashOpts)
 	if err != nil {
 		panic(err)
 	}
diff --git a/identity/identityhash_test.go b/identity/identityhash_test.go
index 52debe293..fee38c8fe 100644
--- a/identity/identityhash_test.go
+++ b/identity/identityhash_test.go
@@ -25,12 +25,12 @@ import (
 func TestHashString(t *testing.T) {
 	c := qt.New(t)
 
-	c.Assert(HashString("a", "b"), qt.Equals, "2712570657419664240")
-	c.Assert(HashString("ab"), qt.Equals, "590647783936702392")
+	c.Assert(HashString("a", "b"), qt.Equals, "3176555414984061461")
+	c.Assert(HashString("ab"), qt.Equals, "7347350983217793633")
 
 	var vals []any = []any{"a", "b", tstKeyer{"c"}}
 
-	c.Assert(HashString(vals...), qt.Equals, "12599484872364427450")
+	c.Assert(HashString(vals...), qt.Equals, "4438730547989914315")
 	c.Assert(vals[2], qt.Equals, tstKeyer{"c"})
 }