Fix route_check.py: intersection-based retry in check_frr_pending_routes

## What I did

Replaced the overwrite-on-each-iteration retry loop with an intersection
accumulator so that only routes stuck in *every* poll window are mitigated.

## Problem with the previous logic

The retry loop called get_frr_routes_parallel() up to FRR_CHECK_RETRIES
times and simply overwrote missed_rt on every iteration:

  for i in range(retries):
      missed_rt, failed_rt = get_frr_routes_parallel(namespace)
      if not missed_rt and not failed_rt:
          break
      time.sleep(FRR_WAIT_TIME)
  # mitigate whatever happened to be in missed_rt at loop exit

Consequence: a route stuck only in the last iteration is
mitigated even though it may be in the middle of normal BGP convergence
(false positive / premature mitigation).

## New logic

Accumulate a running intersection across iterations.  On the first iteration
the accumulator is seeded with the full result set.  On each subsequent
iteration, any prefix no longer present is removed.

  iter 0: {A, B, C, D}   <- seed
  iter 1: {A, B, C}       <- D removed (converged)
  iter 2: {A, B}          <- C removed (converged)
  result: {A, B}          <- truly stuck, safe to mitigate

If the current iteration returns nothing, the intersection becomes empty and
the loop exits early — same fast-path as before for the healthy case.

Signed-off-by: mike-dubrovsky <mdubrovs@cisco.com>

Author: mike-dubrovsky

scripts/route_check.py

@@ -730,20 +730,46 @@ def is_feature_bgp_enabled(namespace):
 
 def check_frr_pending_routes(namespace):
     """
-    Check FRR routes for offload flag presence by executing "show ip route json"
-    Returns a list of routes that have no offload flag.
-    """
-
-    missed_rt = []
-    failed_rt = []
-    retries = FRR_CHECK_RETRIES
-    for i in range(retries):
-        missed_rt, failed_rt = get_frr_routes_parallel(namespace)
-
-        if not missed_rt and not failed_rt:
+    Check FRR routes for offload flag presence by streaming vtysh text output.
+    Returns lists of route dicts {'prefix', 'protocol'} that are persistently
+    non-offloaded across all retry iterations (intersection logic).
+
+    Intersection approach: only routes that appear as stuck in *every* poll
+    are returned for mitigation.  A route that clears between iterations is
+    converging normally and should not be mitigated.
+
+    Example with FRR_CHECK_RETRIES=3:
+      iter 0: {A, B, C, D}
+      iter 1: {A, B, C}        (D converged)
+      iter 2: {A, B}           (C converged)
+      result: {A, B}           <- only truly stuck routes
+    """
+    acc_miss = []
+    acc_fail = []
+
+    for i in range(FRR_CHECK_RETRIES):
+        curr_miss, curr_fail = get_frr_routes_parallel(namespace)
+
+        if i == 0:
+            # Seed: first iteration defines the candidate set
+            acc_miss = curr_miss
+            acc_fail = curr_fail
+        else:
+            # Intersect: keep only prefixes still stuck in this iteration
+            curr_miss_keys = {e['prefix'] for e in curr_miss}
+            curr_fail_keys = {e['prefix'] for e in curr_fail}
+            acc_miss = [e for e in acc_miss if e['prefix'] in curr_miss_keys]
+            acc_fail = [e for e in acc_fail if e['prefix'] in curr_fail_keys]
+
+        if not curr_miss and not curr_fail:
+            # Nothing queued right now; intersection already empty -- stop early
             break
 
-        time.sleep(FRR_WAIT_TIME)
+        if i < FRR_CHECK_RETRIES - 1:
+            time.sleep(FRR_WAIT_TIME)
+
+    missed_rt = acc_miss
+    failed_rt = acc_fail
     print_message(syslog.LOG_DEBUG, f"FRR missed routes: {missed_rt}")
     print_message(syslog.LOG_DEBUG, f"FRR failed routes: {failed_rt}")
     return missed_rt, failed_rt