test(channelserver): replace time.Sleep with polling loops

Blind sleeps accumulate serially (no t.Parallel anywhere) and inflate
under the race detector's scheduling overhead — contributing to the
~136s channelserver test run time.

Replace ~75 arbitrary sleeps (50ms–1s) across 7 test files with 2s
polling loops that exit as soon as the expected condition holds. Sleeps
that are genuinely intentional (race-condition stress tests, cache
expiry, temporal spacing in timestamp tests, backpressure pacing) are
left untouched.

server/channelserver/integration_test.go

@@ -84,7 +84,13 @@ func IntegrationTest_PacketQueueFlow(t *testing.T) {
 
 		done:
 			s.closed.Store(true)
-			time.Sleep(50 * time.Millisecond)
+			deadline := time.Now().Add(2 * time.Second)
+			for time.Now().Before(deadline) {
+				if mock.PacketCount() >= tt.wantPackets {
+					break
+				}
+				time.Sleep(10 * time.Millisecond)
+			}
 
 			sentPackets := mock.GetSentPackets()
 			if len(sentPackets) != tt.wantPackets {
@@ -175,7 +181,13 @@ func IntegrationTest_ConcurrentQueueing(t *testing.T) {
 
 done:
 	s.closed.Store(true)
-	time.Sleep(50 * time.Millisecond)
+	deadline := time.Now().Add(2 * time.Second)
+	for time.Now().Before(deadline) {
+		if mock.PacketCount() >= expectedTotal {
+			break
+		}
+		time.Sleep(10 * time.Millisecond)
+	}
 
 	sentPackets := mock.GetSentPackets()
 	if len(sentPackets) != expectedTotal {
@@ -237,9 +249,14 @@ func IntegrationTest_AckPacketFlow(t *testing.T) {
 	}
 
 	// Wait for ACKs to be sent
-	time.Sleep(200 * time.Millisecond)
 	s.closed.Store(true)
-	time.Sleep(50 * time.Millisecond)
+	deadline := time.Now().Add(2 * time.Second)
+	for time.Now().Before(deadline) {
+		if mock.PacketCount() >= ackCount {
+			break
+		}
+		time.Sleep(10 * time.Millisecond)
+	}
 
 	sentPackets := mock.GetSentPackets()
 	if len(sentPackets) != ackCount {
@@ -307,9 +324,14 @@ func IntegrationTest_MixedPacketTypes(t *testing.T) {
 	s.QueueSendNonBlocking([]byte{0x00, 0x03, 0xEE})
 
 	// Wait for all packets
-	time.Sleep(200 * time.Millisecond)
 	s.closed.Store(true)
-	time.Sleep(50 * time.Millisecond)
+	deadline := time.Now().Add(2 * time.Second)
+	for time.Now().Before(deadline) {
+		if mock.PacketCount() >= 4 {
+			break
+		}
+		time.Sleep(10 * time.Millisecond)
+	}
 
 	sentPackets := mock.GetSentPackets()
 	if len(sentPackets) != 4 {
@@ -357,9 +379,14 @@ func IntegrationTest_PacketOrderPreservation(t *testing.T) {
 	}
 
 	// Wait for packets
-	time.Sleep(300 * time.Millisecond)
 	s.closed.Store(true)
-	time.Sleep(50 * time.Millisecond)
+	deadline := time.Now().Add(2 * time.Second)
+	for time.Now().Before(deadline) {
+		if mock.PacketCount() >= packetCount {
+			break
+		}
+		time.Sleep(10 * time.Millisecond)
+	}
 
 	sentPackets := mock.GetSentPackets()
 	if len(sentPackets) != packetCount {
@@ -423,9 +450,14 @@ func IntegrationTest_QueueBackpressure(t *testing.T) {
 	}
 
 	// Wait for processing
-	time.Sleep(1 * time.Second)
 	s.closed.Store(true)
-	time.Sleep(50 * time.Millisecond)
+	deadline := time.Now().Add(2 * time.Second)
+	for time.Now().Before(deadline) {
+		if mock.PacketCount() > 0 {
+			break
+		}
+		time.Sleep(10 * time.Millisecond)
+	}
 
 	// Some packets should have been sent
 	sentCount := mock.PacketCount()
@@ -502,7 +534,13 @@ func IntegrationTest_GuildEnumerationFlow(t *testing.T) {
 
 		done:
 			s.closed.Store(true)
-			time.Sleep(50 * time.Millisecond)
+			deadline := time.Now().Add(2 * time.Second)
+			for time.Now().Before(deadline) {
+				if mock.PacketCount() >= tt.guildCount {
+					break
+				}
+				time.Sleep(10 * time.Millisecond)
+			}
 
 			sentPackets := mock.GetSentPackets()
 			if len(sentPackets) != tt.guildCount {
@@ -571,9 +609,21 @@ func IntegrationTest_ConcurrentClientAccess(t *testing.T) {
 						s.QueueSend(testData)
 					}
 
-					time.Sleep(100 * time.Millisecond)
+					deadline := time.Now().Add(2 * time.Second)
+					for time.Now().Before(deadline) {
+						if mock.PacketCount() >= tt.packetsPerClient {
+							break
+						}
+						time.Sleep(10 * time.Millisecond)
+					}
 					s.closed.Store(true)
-					time.Sleep(50 * time.Millisecond)
+					deadline = time.Now().Add(2 * time.Second)
+					for time.Now().Before(deadline) {
+						if mock.PacketCount() >= tt.packetsPerClient {
+							break
+						}
+						time.Sleep(10 * time.Millisecond)
+					}
 
 					sentCount := mock.PacketCount()
 					mu.Lock()
@@ -638,9 +688,21 @@ func IntegrationTest_ClientVersionCompatibility(t *testing.T) {
 			testData := []byte{0x00, 0x01, 0xAA, 0xBB}
 			s.QueueSend(testData)
 
-			time.Sleep(100 * time.Millisecond)
+			deadline := time.Now().Add(2 * time.Second)
+			for time.Now().Before(deadline) {
+				if mock.PacketCount() >= 1 {
+					break
+				}
+				time.Sleep(10 * time.Millisecond)
+			}
 			s.closed.Store(true)
-			time.Sleep(50 * time.Millisecond)
+			deadline = time.Now().Add(2 * time.Second)
+			for time.Now().Before(deadline) {
+				if mock.PacketCount() >= 1 {
+					break
+				}
+				time.Sleep(10 * time.Millisecond)
+			}
 
 			sentCount := mock.PacketCount()
 			if (sentCount > 0) != tt.shouldSucceed {
@@ -674,9 +736,14 @@ func IntegrationTest_PacketPrioritization(t *testing.T) {
 		s.QueueSend([]byte{0x00, byte(i), 0xDD})
 	}
 
-	time.Sleep(200 * time.Millisecond)
 	s.closed.Store(true)
-	time.Sleep(50 * time.Millisecond)
+	deadline := time.Now().Add(2 * time.Second)
+	for time.Now().Before(deadline) {
+		if mock.PacketCount() >= 10 {
+			break
+		}
+		time.Sleep(10 * time.Millisecond)
+	}
 
 	sentPackets := mock.GetSentPackets()
 	if len(sentPackets) < 10 {
@@ -732,7 +799,13 @@ func IntegrationTest_DataIntegrityUnderLoad(t *testing.T) {
 
 done:
 	s.closed.Store(true)
-	time.Sleep(50 * time.Millisecond)
+	deadline := time.Now().Add(2 * time.Second)
+	for time.Now().Before(deadline) {
+		if mock.PacketCount() >= packetCount {
+			break
+		}
+		time.Sleep(10 * time.Millisecond)
+	}
 
 	sentPackets := mock.GetSentPackets()
 	if len(sentPackets) != packetCount {