Evict stale overlay advert when retry hits NoTransportForType

The advert cache inside fetch_advert is read-only on hit — once a peer's
overlay advert is cached, every subsequent lookup returns the same
endpoints regardless of whether they still work. So when a peer rebinds
its NAT (or its STUN-discovered port flaps), connection retries to that
peer dial the same dead address forever, even with exponential backoff
firing at the right cadence.

Observed in deployment: macOS daemon's view of a Linux peer would
"regress" — peer marked rch=False after a brief link-dead window, then
hours of "Retry connection initiation failed: no operational transport
for any of <npub>'s addresses" with no recovery. Manual pause+resume of
the daemon (which restarts the FIPS endpoint and forces fresh advert
fetches) was the only way out.

When initiate_peer_connection / a retry tick returns
NodeError::NoTransportForType, fire-and-forget refetch_advert_for_stale_check
on the peer's npub. This re-fetches kind 37195 from advert_relays; if
the relay has a newer advert it replaces the cached entry, if it has
nothing it evicts the cached entry. Either way the next retry tick goes
to fresh data instead of looping on the same dead endpoint.

Mirrors the existing stale-advert sweep that runs from the
BootstrapEvent::Failed (NAT-traversal-streak) path, but covers the
direct-UDP-retry path which never crosses that streak threshold.

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

src/node/lifecycle.rs

@@ -79,6 +79,19 @@ impl Node {
                 if let Ok(peer_identity) = PeerIdentity::from_npub(&peer_config.npub) {
                     self.schedule_retry(*peer_identity.node_addr(), Self::now_ms());
                 }
+                // No-transport failures most often mean the cached overlay
+                // advert is pointing at a dead post-NAT-rebind address. The
+                // advert cache is read-only inside fetch_advert, so retries
+                // would loop on the same dead address until expiry. Force a
+                // re-fetch so the next retry tick picks up fresh endpoints.
+                if matches!(e, crate::node::NodeError::NoTransportForType(_))
+                    && let Some(bootstrap) = self.nostr_discovery.clone()
+                {
+                    let npub = peer_config.npub.clone();
+                    tokio::spawn(async move {
+                        let _ = bootstrap.refetch_advert_for_stale_check(&npub).await;
+                    });
+                }
             }
         }
     }

src/node/retry.rs

@@ -4,7 +4,7 @@
 //! automatically retry with exponential backoff. Retry state lives on Node
 //! (not PeerConnection) because each retry creates a fresh connection.
 
-use super::Node;
+use super::{Node, NodeError};
 use crate::PeerIdentity;
 use crate::config::PeerConfig;
 use crate::identity::NodeAddr;
@@ -301,6 +301,20 @@ impl Node {
                         error = %e,
                         "Retry connection initiation failed"
                     );
+                    // No-transport failures usually mean the cached overlay
+                    // advert is stale (peer rebound NAT, switched relay, etc.).
+                    // The advert cache is read-only inside fetch_advert, so
+                    // every retry returns the same dead address until the
+                    // entry expires. Force a re-fetch so the next retry tick
+                    // picks up fresh endpoints.
+                    if matches!(e, NodeError::NoTransportForType(_))
+                        && let Some(bootstrap) = self.nostr_discovery.clone()
+                    {
+                        let npub = peer_config.npub.clone();
+                        tokio::spawn(async move {
+                            let _ = bootstrap.refetch_advert_for_stale_check(&npub).await;
+                        });
+                    }
                     // Immediate failure counts as an attempt — schedule next retry
                     // (reconnect flag is preserved on existing retry_pending entry)
                     self.schedule_retry(node_addr, now_ms);