Fix potential deadlock with nested GetOrCreate calls

The new revived lock logic is also faster:

```
name               old time/op    new time/op    delta
NewGetOrCreate-10     301µs ± 0%     101µs ± 0%  -66.59%  (p=0.004 n=6+5)

name               old alloc/op   new alloc/op   delta
NewGetOrCreate-10     19.3B ± 3%     19.7B ± 3%     ~     (p=0.567 n=6+6)

name               old allocs/op  new allocs/op  delta
NewGetOrCreate-10      0.00           0.00          ~     (all equal)
```

Author: bep

lazycache.go

@@ -86,16 +86,16 @@ func (c *Cache[K, V]) Get(key K) (V, bool) {
 // Note that create, the cache prime function, is called once and then not called again for a given key
 // unless the cache entry is evicted; it does not block other goroutines from calling GetOrCreate,
 // it is not called with the cache lock held.
+// Note that any error returned by create will be returned by GetOrCreate and repeated calls with the same key will
+// receive the same error.
 func (c *Cache[K, V]) GetOrCreate(key K, create func(key K) (V, error)) (V, bool, error) {
 	c.mu.Lock()
 	w := c.get(key)
 	if w != nil {
+		c.mu.Unlock()
 		w.wait()
-		// if w.ready is set then w comes from a concurrent GetOrCreate call.
-		if w.found || w.ready != nil {
-			c.mu.Unlock()
-			return w.value, w.found, nil
-		}
+		// If w.ready is nil, we will repeat any error from the create function to concurrent callers.
+		return w.value, w.found, w.err
 	}
 
 	w = &valueWrapper[V]{

lazycache_test.go

@@ -200,7 +200,59 @@ func TestGetOrCreateConcurrent(t *testing.T) {
 	wg.Wait()
 }
 
-func BenchmarkGetOrCreate(b *testing.B) {
+func TestGetOrCreateRecursive(t *testing.T) {
+	c := qt.New(t)
+
+	var wg sync.WaitGroup
+
+	n := 200
+
+	for i := 0; i < 30; i++ {
+		cache := New[int, any](Options{MaxEntries: 1000})
+
+		for j := 0; j < 10; j++ {
+			wg.Add(1)
+			go func() {
+				defer wg.Done()
+				for k := 0; k < 10; k++ {
+					// This test was added to test a deadlock situation with nested GetOrCreate calls on the same cache.
+					// Note that the keys below are carefully selected to not overlap, as this case may still deadlock:
+					// goroutine 1: GetOrCreate(1) => GetOrCreate(2)
+					// goroutine 2: GetOrCreate(2) => GetOrCreate(1)
+					key1, key2 := rand.Intn(n), rand.Intn(n)+n
+					if key2 == key1 {
+						key2++
+					}
+					shouldFail := key1%10 == 0
+					v, found, err := cache.GetOrCreate(key1, func(key int) (any, error) {
+						if shouldFail {
+							return nil, fmt.Errorf("failed")
+						}
+						v, _, err := cache.GetOrCreate(key2, func(key int) (any, error) {
+							return "inner", nil
+						})
+						c.Assert(err, qt.IsNil)
+						return v, nil
+					})
+
+					if shouldFail {
+						c.Assert(err, qt.ErrorMatches, "failed")
+						c.Assert(v, qt.IsNil)
+						c.Assert(found, qt.IsFalse)
+					} else {
+						c.Assert(err, qt.IsNil)
+						c.Assert(found, qt.IsTrue)
+						c.Assert(v, qt.Equals, "inner")
+					}
+				}
+			}()
+
+		}
+		wg.Wait()
+	}
+}
+
+func BenchmarkGetOrCreateAndGet(b *testing.B) {
 	const maxSize = 1000
 
 	runBenchmark := func(b *testing.B, cache *Cache[int, any], getOrCreate func(key int, create func(key int) (any, error)) (any, bool, error)) {
@@ -249,6 +301,45 @@ func BenchmarkGetOrCreate(b *testing.B) {
 
 }
 
+func BenchmarkGetOrCreate(b *testing.B) {
+	const maxSize = 1000
+
+	r := rand.New(rand.NewSource(99))
+	var mu sync.Mutex
+
+	cache := New[int, any](Options{MaxEntries: maxSize})
+
+	// Partially fill the cache.
+	for i := 0; i < maxSize/3; i++ {
+		cache.Set(i, i)
+	}
+	b.ResetTimer()
+
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			mu.Lock()
+			i2 := r.Intn(maxSize)
+			mu.Unlock()
+
+			res2, found, err := cache.GetOrCreate(i2, func(key int) (any, error) {
+				if i2%100 == 0 {
+					// Simulate a slow create.
+					time.Sleep(1 * time.Second)
+				}
+				return i2, nil
+			})
+
+			if err != nil {
+				b.Fatal(err)
+			}
+
+			if v := res2; !found || v != i2 {
+				b.Fatalf("got %v, want %v", v, i2)
+			}
+		}
+	})
+}
+
 func BenchmarkCacheSerial(b *testing.B) {
 	const maxSize = 1000