Refetch overlay advert before every retry, not only on NoTransportForType

The previous fix (6ebca3e) only refetched the advert when retry returned
NodeError::NoTransportForType (cache returned no addresses at all). But
the much more common stale-cache failure mode is: cache returns an
endpoint that LOOKS valid (the address it had last week, before the
peer's NAT rebound), the dial succeeds at the IP layer, the handshake
times out, MMP fires, schedule_reconnect adds the entry back to
retry_pending, next retry hits the same cached endpoint, dials it
again, times out again. Loop forever — no NoTransportForType ever
fires because the cache has data, just dead data.

Move refetch_advert_for_stale_check to before each retry attempt
unconditionally. Cheap (one Filter query against advert_relays with
a 2s timeout, bounded by the retry backoff cadence), and replaces the
cache only if the relay has a newer advert or evicts if the relay has
nothing. Keeps the retry loop pinned to relay ground truth instead of
whatever the cache happened to learn at startup.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

src/node/retry.rs

@@ -259,6 +259,25 @@ impl Node {
 
             let peer_config = state.peer_config.clone();
 
+            // Refresh the peer's overlay advert before retrying. The cache is
+            // read-only on hit (see fetch_advert), so every retry without a
+            // refetch dials the same cached endpoint — and the most common
+            // reason a peer ended up in retry_pending is that the cached
+            // endpoint just stopped working (NAT rebind, port change, peer
+            // restart on a different port). Without this refresh the retry
+            // loop dials the same dead address forever.
+            //
+            // refetch_advert_for_stale_check uses the relay's advert as
+            // ground truth: replaces the cache if there's a newer one,
+            // evicts if the relay has nothing, otherwise leaves it. Cheap
+            // (one Filter fetch with 2s timeout) and bounded by the retry
+            // backoff cadence.
+            if let Some(bootstrap) = self.nostr_discovery.clone() {
+                let _ = bootstrap
+                    .refetch_advert_for_stale_check(&peer_config.npub)
+                    .await;
+            }
+
             match self.initiate_peer_connection(&peer_config).await {
                 Ok(()) => {
                     // Push retry_after_ms past the handshake timeout window so