fix(sqs/throttle): drop dead sweep state + add throttle idempotency test (PR #679 round 2)

Two items from the round-2 Claude review on PR #679:

(1) bucketStore.sweepMu and bucketStore.lastSweep became dead code
when the move from on-hot-path maybeSweep to the background
runSweepLoop landed in round 1. The sweep() ticker is the only
caller, so the serialisation primitive that protected against
concurrent on-hot-path callers no longer has a job. Removed both
fields and the sweepMu.Lock/lastSweep=now/sweepMu.Unlock block;
sweep() now reads b.clock() inline. Field comment updated to
describe the post-runSweepLoop design (single-goroutine driver).

(2) TestSQSServer_CatalogCreateIsIdempotent now exercises
throttleConfigEqual via a fourth case: same name, same
VisibilityTimeout, but the second create adds Throttle* attributes.
attributesEqual must notice the diff and the call must reject as
QueueNameExists. Without this case a future bug in
throttleConfigEqual (e.g. always returning true) would slip past
the existing VisibilityTimeout-only test.

Both findings noted in the round-2 Claude review on PR #679.

Author: bootjp

adapter/sqs_catalog_test.go

@@ -136,6 +136,29 @@ func TestSQSServer_CatalogCreateIsIdempotent(t *testing.T) {
 	if got, _ := out3["__type"].(string); got != sqsErrQueueNameExists {
 		t.Fatalf("differing-attrs error type: got %q want %q", got, sqsErrQueueNameExists)
 	}
+
+	// Fourth call: same name, same non-throttle attrs as the original
+	// create, but different Throttle* values. The original create had
+	// no Throttle config; this one adds one. throttleConfigEqual must
+	// notice the diff and the call must reject as QueueNameExists.
+	// Without this case a bug in throttleConfigEqual (e.g. always
+	// returning true) would slip past the existing VisibilityTimeout-
+	// only test (Claude review on PR #679 round 2).
+	withThrottle := map[string]any{
+		"QueueName": "idempotent",
+		"Attributes": map[string]string{
+			"VisibilityTimeout":           "60",
+			"ThrottleSendCapacity":        "10",
+			"ThrottleSendRefillPerSecond": "1",
+		},
+	}
+	status4, out4 := callSQS(t, node, sqsCreateQueueTarget, withThrottle)
+	if status4 != http.StatusBadRequest {
+		t.Fatalf("re-create with added Throttle*: got %d want 400; body %v", status4, out4)
+	}
+	if got, _ := out4["__type"].(string); got != sqsErrQueueNameExists {
+		t.Fatalf("Throttle*-diff error type: got %q want %q", got, sqsErrQueueNameExists)
+	}
 }
 
 func TestSQSServer_CatalogGetAndSetAttributes(t *testing.T) {

adapter/sqs_throttle.go

@@ -105,15 +105,13 @@ type tokenBucket struct {
 // bucketStore holds every active bucket for an SQS server process.
 // sync.Map matches the read-mostly access pattern: lookups are nearly
 // always Load hits; LoadOrStore pays the write cost only on first use.
+//
+// The idle-evict sweep runs from runSweepLoop on a background ticker
+// — there is no hot-path serialisation primitive because the only
+// caller of sweep() is the sole goroutine the ticker drives.
 type bucketStore struct {
-	buckets sync.Map // map[bucketKey]*tokenBucket
-	clock   func() time.Time
-	// sweepMu serialises the lazy idle-evict sweep so concurrent first
-	// requests cannot all run a full sweep in parallel. The sweep itself
-	// acquires per-bucket mu briefly, so it never blocks a lookup that
-	// already has the bucket.
-	sweepMu      sync.Mutex
-	lastSweep    time.Time
+	buckets      sync.Map // map[bucketKey]*tokenBucket
+	clock        func() time.Time
 	evictedAfter time.Duration
 	sweepEvery   time.Duration
 }
@@ -305,17 +303,14 @@ func (b *bucketStore) runSweepLoop(ctx context.Context) {
 }
 
 // sweep walks the bucket store dropping any bucket idle longer than
-// evictedAfter. Called from runSweepLoop on a background ticker.
-// Bucket lookups are still O(1) on the hot path; sweep iterates
-// every entry under the per-bucket lock (held briefly for the
-// timestamp read) so it never blocks a charge() that already has
+// evictedAfter. Called from runSweepLoop on a background ticker —
+// the ticker is the only caller, so sweep() does not need its own
+// serialisation. Bucket lookups stay O(1) on the hot path; sweep
+// iterates every entry under the per-bucket lock (held briefly for
+// the timestamp read) so it never blocks a charge() that already has
 // the bucket.
 func (b *bucketStore) sweep() {
-	now := b.clock()
-	b.sweepMu.Lock()
-	b.lastSweep = now
-	b.sweepMu.Unlock()
-	cutoff := now.Add(-b.evictedAfter)
+	cutoff := b.clock().Add(-b.evictedAfter)
 	b.buckets.Range(func(k, v any) bool {
 		bucket, _ := v.(*tokenBucket)
 		bucket.mu.Lock()