test(linked): cover free-list reuse and cap-reached branches

The node free list added in this branch introduced two new branches
that the existing tests didn't hit — "Offer after Get reuses a
recycled node" and "drain past freeCap stops growing the free list".
Coverage fell to 98.4% and the 100% gate failed.

Add a dedicated sub-test that exercises both paths. No observable
behaviour change.

Author: adrianbrad

linked_test.go

@@ -22,6 +22,69 @@ func TestLinked(t *testing.T) {
 	t.Run("Reset", testLinkedReset)
 	t.Run("Iterator", testLinkedIterator)
 	t.Run("MarshalJSON", testLinkedMarshalJSON)
+	t.Run("NodeRecycling", testLinkedNodeRecycling)
+}
+
+// testLinkedNodeRecycling exercises both branches of the internal free
+// list: Offer after Get reuses a recycled node, and draining past the
+// free list's cap stops growing it. Purely a coverage driver; observable
+// behaviour is identical to an unpooled implementation.
+func testLinkedNodeRecycling(t *testing.T) {
+	t.Parallel()
+
+	t.Run("OfferReusesPoppedNode", func(t *testing.T) {
+		t.Parallel()
+
+		linkedQueue := queue.NewLinked([]int{1, 2, 3})
+
+		got, err := linkedQueue.Get()
+		if err != nil || got != 1 {
+			t.Fatalf("get: %d %v", got, err)
+		}
+
+		// This Offer should hit the free-list-has-node path.
+		if err := linkedQueue.Offer(4); err != nil {
+			t.Fatalf("offer: %v", err)
+		}
+
+		cleared := linkedQueue.Clear()
+		expected := []int{2, 3, 4}
+
+		if !reflect.DeepEqual(expected, cleared) {
+			t.Fatalf("expected %v got %v", expected, cleared)
+		}
+	})
+
+	t.Run("DrainBeyondFreeCap", func(t *testing.T) {
+		t.Parallel()
+
+		// Use a size that exceeds the free-list cap so the cap-reached
+		// branch of recycle() executes.
+		const n = 128
+
+		linkedQueue := queue.NewLinked[int](nil)
+
+		for i := 0; i < n; i++ {
+			if err := linkedQueue.Offer(i); err != nil {
+				t.Fatalf("offer %d: %v", i, err)
+			}
+		}
+
+		for i := 0; i < n; i++ {
+			got, err := linkedQueue.Get()
+			if err != nil {
+				t.Fatalf("get %d: %v", i, err)
+			}
+
+			if got != i {
+				t.Fatalf("get %d: want %d got %d", i, i, got)
+			}
+		}
+
+		if !linkedQueue.IsEmpty() {
+			t.Fatal("queue should be empty")
+		}
+	})
 }
 
 func testLinkedGet(t *testing.T) {