Make the routewatch tests pass on a loaded host (closes #213)

Five prefix handler tests gave HandleMessage two seconds to apply a full
batch of 25,000 prefixes, which under the race detector on a loaded host
takes longer. A test now waits up to stepTimeout, 15 seconds, for each step
it expects.

The slowest tests filled production limits, such as the peering handler's
500,000 paths. The peering handler now takes its path limit, and the prefix
handler its limit on one write of the table's changes, as they take their
timer interval. Those tests give small limits, and the tests of the maximum
batch size lower it to one batch. This also fixes
#215.

The test helpers bound every wait, Stop included, so a test that hangs in
one fails with its own message.

Model: opus-5-5

internal/routewatch/peeringhandler.go

@@ -42,6 +42,10 @@ type PeeringHandler struct {
 	db     database.Store
 	logger *logger.Logger
 
+	// maxPaths is the most paths asPaths holds: maxTrackedPaths, except in
+	// tests that give a smaller one.
+	maxPaths int
+
 	// In-memory AS path tracking: each path, JSON-encoded, with the earliest
 	// and the latest time an update carried it.
 	mu           sync.Mutex
@@ -62,21 +66,24 @@ type PeeringHandler struct {
 // periodically processes accumulated AS paths into peering records. The
 // handler begins processing immediately upon creation.
 func NewPeeringHandler(db database.Store, logger *logger.Logger) *PeeringHandler {
-	return newPeeringHandler(db, logger, peeringProcessInterval)
+	return newPeeringHandler(db, logger, peeringProcessInterval, maxTrackedPaths)
 }
 
 // newPeeringHandler is NewPeeringHandler with the processing timer's interval,
-// processInterval, in place of peeringProcessInterval. A test gives a short
-// one to have the timer start a write.
+// processInterval, in place of peeringProcessInterval, and the most paths it
+// holds, maxPaths, in place of maxTrackedPaths. A test gives a short interval to
+// have the timer start a write, and a small maxPaths to fill the map quickly.
 func newPeeringHandler(
 	db database.Store, logger *logger.Logger, processInterval time.Duration,
+	maxPaths int,
 ) *PeeringHandler {
 	h := &PeeringHandler{
-		db:      db,
-		logger:  logger,
-		asPaths: make(map[string]database.SeenTimes),
-		stopCh:  make(chan context.Context, 1),
-		done:    make(chan struct{}),
+		db:       db,
+		logger:   logger,
+		asPaths:  make(map[string]database.SeenTimes),
+		maxPaths: maxPaths,
+		stopCh:   make(chan context.Context, 1),
+		done:     make(chan struct{}),
 	}
 
 	// Start the periodic processing goroutine
@@ -131,7 +138,7 @@ func (h *PeeringHandler) HandleMessage(msg *ristypes.RISMessage) {
 	defer h.mu.Unlock()
 
 	seen, exists := h.asPaths[key]
-	if !exists && len(h.asPaths) >= maxTrackedPaths {
+	if !exists && len(h.asPaths) >= h.maxPaths {
 		// Map is full; drop this new path and count it.
 		h.droppedPaths++