chore(spec): clean up fellowship sediment + isolate races per run

Two-pronged fix for the shared-app data leak that pollutes client_spec
queries:

1. Active cleanup in before(:all): query_users by the four well-known
   fellowship names (Frodo / Sam / Gandalf / Legolas) and hard-delete
   any leftovers from prior runs whose after(:all) didn't fire.
   delete_users is idempotent, so this is safe to re-run.
2. Per-run unique race tag (e.g. 'Hobbit-aBcD1234') so the queries-users
   test stays isolated from concurrent runs and from the sliver between
   the cleanup above and the new upserts.

The active-cleanup half stops the sediment from growing forever — the
random-tag-only patch (prior attempt) inserts new users with new tags
every run, so the shared app keeps accumulating users indefinitely.

Per-PR scratch app via create_app is still the right long-term fix and
is tracked separately.

Author: nijeesh-stream

spec/client_spec.rb

@@ -25,11 +25,39 @@ def loop_times(times)
 
     @created_users = []
 
+    # Active cleanup: hard-delete fellowship leftovers from prior CI runs whose
+    # after(:all) didn't fire. delete_users is idempotent — safe whether or not
+    # the previous run cleaned up. Without this the shared test app accumulates
+    # Frodos / Sams / Gandalfs / Legolases forever and other tests that query
+    # users by name end up matching sediment.
+    begin
+      leftover = @client.query_users(
+        { 'name' => { '$in' => ['Frodo Baggins', 'Samwise Gamgee',
+                                'Gandalf the Grey', 'Legolas'] } }
+      )
+      leftover_ids = leftover['users'].map { |u| u['id'] }
+      if leftover_ids.any?
+        @client.delete_users(leftover_ids,
+                             user: StreamChat::HARD_DELETE,
+                             messages: StreamChat::HARD_DELETE)
+      end
+    rescue StandardError
+      # Best-effort: a failed cleanup must not block tests; concurrent-run
+      # protection below handles the residual case.
+    end
+
+    # Per-run race markers so concurrent CI runs (and the seconds-window between
+    # the active cleanup above and the upserts below) don't collide on
+    # race=Hobbit / Elf / Istari lookups.
+    @hobbit_race = "Hobbit-#{SecureRandom.alphanumeric(8)}"
+    @elf_race = "Elf-#{SecureRandom.alphanumeric(8)}"
+    @istari_race = "Istari-#{SecureRandom.alphanumeric(8)}"
+
     @fellowship_of_the_ring = [
-      { id: SecureRandom.uuid, name: 'Frodo Baggins', race: 'Hobbit', age: 50 },
-      { id: SecureRandom.uuid, name: 'Samwise Gamgee', race: 'Hobbit', age: 38 },
-      { id: SecureRandom.uuid, name: 'Gandalf the Grey', race: 'Istari' },
-      { id: SecureRandom.uuid, name: 'Legolas', race: 'Elf', age: 500 }
+      { id: SecureRandom.uuid, name: 'Frodo Baggins', race: @hobbit_race, age: 50 },
+      { id: SecureRandom.uuid, name: 'Samwise Gamgee', race: @hobbit_race, age: 38 },
+      { id: SecureRandom.uuid, name: 'Gandalf the Grey', race: @istari_race },
+      { id: SecureRandom.uuid, name: 'Legolas', race: @elf_race, age: 500 }
     ]
 
     @legolas = @fellowship_of_the_ring[3][:id]
@@ -588,7 +616,7 @@ def loop_times(times)
   end
 
   it 'queries users' do
-    response = @client.query_users({ 'race' => { '$eq' => 'Hobbit' } }, sort: { 'age' => -1 })
+    response = @client.query_users({ 'race' => { '$eq' => @hobbit_race } }, sort: { 'age' => -1 })
     expect(response['users'].length).to eq 2
     expect([50, 38]).to eq(response['users'].map { |u| u['age'] })
   end
@@ -1025,20 +1053,30 @@ def loop_times(times)
       expect(cmd['description']).to eq 'I am testing'
     end
 
+    # Each follow-up step is wrapped in loop_times to absorb the backend's
+    # eventual-consistency lag between Create / Get / Update / Delete — on a
+    # cold shared CI app the next call regularly hits "the command ... does
+    # not exist" until the write propagates.
     it 'get that command' do
-      cmd = @client.get_command(@cmd)
-      expect(cmd['name']).to eq @cmd
-      expect(cmd['description']).to eq 'I am testing'
+      loop_times 10 do
+        cmd = @client.get_command(@cmd)
+        expect(cmd['name']).to eq @cmd
+        expect(cmd['description']).to eq 'I am testing'
+      end
     end
 
     it 'update that command' do
-      cmd = @client.update_command(@cmd, { description: 'I tested' })['command']
-      expect(cmd['name']).to eq @cmd
-      expect(cmd['description']).to eq 'I tested'
+      loop_times 10 do
+        cmd = @client.update_command(@cmd, { description: 'I tested' })['command']
+        expect(cmd['name']).to eq @cmd
+        expect(cmd['description']).to eq 'I tested'
+      end
     end
 
     it 'delete that command' do
-      @client.delete_command(@cmd)
+      loop_times 10 do
+        @client.delete_command(@cmd)
+      end
     end
 
     it 'list commands' do