Fix exponential backoff overflow race (#41)

Fixes a pre-existing concurrency bug in `exponentialBackoff.Next`, and
folds in the modernization follow-ups that missed the #40 merge.

## Overflow race

`Next` incremented the attempt counter with `Add(1)`, and on overflow
decremented it again (`Add(^uint64(0))`) to un-count the attempt. That
increment-then-decrement is not atomic as a unit, so under concurrent
calls the counter transiently runs past the overflow point and `base <<
attempt` wraps to a bogus positive instead of saturating at `MaxInt64`.

The counter now advances with a compare-and-swap that only commits when
the shift does not overflow. Once it does, `Next` saturates without
advancing, so concurrent callers converge on `MaxInt64`
deterministically.

This flake predates the Go 1.25 work: `TestExponentialBackoff/overflow`
failed ~8/100 runs under `-race` on the merged `main`, ~14/100 on the
modernization branch (the atomic-type swap was equivalent, so the rate
is unchanged within noise). With the fix, the overflow tests pass 0
failures across 60+ `-race` runs. A new
`TestExponentialBackoff_ConcurrentOverflow` fires 100 concurrent `Next`
calls and asserts every result stays on the doubling sequence or
`MaxInt64`.

## Modernization follow-ups

These were staged during the self-review of #40 but did not land before
it merged:

- README: the randomization note still described `math/rand` seeded from
the Unix timestamp; it is now `math/rand/v2` with an automatically
seeded top-level generator.
- Removed the blank lines left behind when the `tc := tc` copies were
dropped.
- Converted the index-free goroutine loops in the concurrent tests to
range-over-int.
- Updated the jitter guard comments to reference `rand.Int64N` instead
of the removed `Int63n`.

---------

Signed-off-by: Seth Vargo <seth@sethvargo.com>

Author: sethvargo

README.md

@@ -178,8 +178,8 @@ Benchmark/sethvargo-7    203,914,245     5.73 ns/op
 
 ## Notes and Caveats
 
-- Randomization uses `math/rand` seeded with the Unix timestamp instead of
-  `crypto/rand`.
+- Randomization uses `math/rand/v2` (non-cryptographic, automatically seeded),
+  not `crypto/rand`.
 - Ordering of addition of multiple modifiers will make a difference.
   For example; ensure you add `CappedDuration` before `WithMaxDuration`, otherwise it may early out too early.
   Another example is you could add `Jitter` before or after capping depending on your desired outcome.

backoff_constant_test.go

@@ -63,14 +63,13 @@ func TestConstantBackoff(t *testing.T) {
 	}
 
 	for _, tc := range cases {
-
 		t.Run(tc.name, func(t *testing.T) {
 			t.Parallel()
 
 			b := retry.NewConstant(tc.base)
 
 			resultsCh := make(chan time.Duration, tc.tries)
-			for i := 0; i < tc.tries; i++ {
+			for range tc.tries {
 				go func() {
 					r, _ := b.Next()
 					resultsCh <- r

backoff_exponential.go

@@ -37,11 +37,15 @@ func NewExponential(base time.Duration) Backoff {
 
 // Next implements Backoff. It is safe for concurrent use.
 func (b *exponentialBackoff) Next() (time.Duration, bool) {
-	next := b.base << (b.attempt.Add(1) - 1)
-	if next <= 0 {
-		b.attempt.Add(^uint64(0))
-		next = math.MaxInt64
-	}
+	for {
+		attempt := b.attempt.Load()
+		next := b.base << attempt
+		if next <= 0 {
+			return math.MaxInt64, false
+		}
 
-	return next, false
+		if b.attempt.CompareAndSwap(attempt, attempt+1) {
+			return next, false
+		}
+	}
 }

backoff_exponential_test.go

@@ -69,14 +69,13 @@ func TestExponentialBackoff(t *testing.T) {
 	}
 
 	for _, tc := range cases {
-
 		t.Run(tc.name, func(t *testing.T) {
 			t.Parallel()
 
 			b := retry.NewExponential(tc.base)
 
 			resultsCh := make(chan time.Duration, tc.tries)
-			for i := 0; i < tc.tries; i++ {
+			for range tc.tries {
 				go func() {
 					r, _ := b.Next()
 					resultsCh <- r
@@ -115,3 +114,47 @@ func ExampleNewExponential() {
 	// 8s
 	// 16s
 }
+
+func TestExponentialBackoff_ConcurrentOverflow(t *testing.T) {
+	t.Parallel()
+
+	// Many concurrent Next calls on an overflow-prone base must never observe a
+	// value outside the doubling sequence or MaxInt64. A racy attempt counter
+	// lets the shift run past the overflow point and wrap to a bogus positive.
+	const tries = 100
+	base := 100_000 * time.Hour
+
+	b := retry.NewExponential(base)
+
+	resultsCh := make(chan time.Duration, tries)
+	for range tries {
+		go func() {
+			r, _ := b.Next()
+			resultsCh <- r
+		}()
+	}
+
+	results := make([]time.Duration, tries)
+	for i := range tries {
+		select {
+		case val := <-resultsCh:
+			results[i] = val
+		case <-time.After(5 * time.Second):
+			t.Fatal("timeout")
+		}
+	}
+	slices.Sort(results)
+
+	want := make([]time.Duration, 0, tries)
+	for next := base; next > 0; next <<= 1 {
+		want = append(want, next)
+	}
+	for len(want) < tries {
+		want = append(want, math.MaxInt64)
+	}
+	slices.Sort(want)
+
+	if !reflect.DeepEqual(results, want) {
+		t.Errorf("expected \n\n%v\n\n to be \n\n%v\n\n", results, want)
+	}
+}

backoff_fibonacci_test.go

@@ -81,14 +81,13 @@ func TestFibonacciBackoff(t *testing.T) {
 	}
 
 	for _, tc := range cases {
-
 		t.Run(tc.name, func(t *testing.T) {
 			t.Parallel()
 
 			b := retry.NewFibonacci(tc.base)
 
 			resultsCh := make(chan time.Duration, tc.tries)
-			for i := 0; i < tc.tries; i++ {
+			for range tc.tries {
 				go func() {
 					r, _ := b.Next()
 					resultsCh <- r

backoff_test.go

@@ -84,11 +84,10 @@ func TestWithJitter_NonPositive(t *testing.T) {
 	}
 
 	for _, tc := range cases {
-
 		t.Run(tc.name, func(t *testing.T) {
 			t.Parallel()
 
-			// A non-positive jitter must not panic (Int63n panics on a
+			// A non-positive jitter must not panic (rand.Int64N panics on a
 			// non-positive argument) and must return the underlying value
 			// unchanged.
 			b := retry.WithJitter(tc.j, retry.BackoffFunc(func() (time.Duration, bool) {
@@ -165,11 +164,10 @@ func TestWithJitterPercent_Zero(t *testing.T) {
 	}
 
 	for _, tc := range cases {
-
 		t.Run(tc.name, func(t *testing.T) {
 			t.Parallel()
 
-			// A zero jitter must not panic (Int63n panics on a non-positive
+			// A zero jitter must not panic (rand.Int64N panics on a non-positive
 			// argument) and must return the underlying value unchanged.
 			b := retry.WithJitterPercent(tc.j, retry.BackoffFunc(func() (time.Duration, bool) {
 				return tc.nextVal, tc.nextStop