feat: prune old, inactive paths (#3666)

## Description

Whenever we insert a new path, trigger pruning paths.

We currently only prune IP paths, and pruning paths only occurs if we
have more than 30 IP paths.

We will prune any paths that did not successfully holepunch. 

If there are still over 30 IP paths left, then we order the "inactive"
paths (paths that have been closed, but at one point holepunched), and
prune the paths that were closed earliest.

## Notes and Questions

- Added constants:
    - `MAX_IP_PATHS` = 30 - maximum IP paths per endpoint
    - `MAX_INACTIVE_IP_PATHS` = 10 - maximum inactive IP paths to keep
- New `PathState` field:
    - `status` - tracks the `PathStatus` of the path
- New `PathStatus` enum:
    -  `PathStatus::Open` - is an open path
    - `PathStatus::Inactive(Instant)` - was opened once, but currently inactive
    - `PathStatus::Unusable` - we attempted to use it, but it never connected
    - `PathStatus::Unknown` - we don't know the status yet
- New methods on `RemotePathState`:
  - `abandoned_path` - marks a path as abandoned with timestamp, triggered when we get the `PathEvent::Abandoned` event
  - `prune_paths` - triggers path pruning, occurs whenever we insert a path to the `RemotePathState`
  - changed `insert` to `insert_open_path`
- New `prune_ip_paths` function with all the prune logic:
    - Only prunes if IP paths exceed `MAX_IP_PATHS`
    - Never prunes active paths or paths of unknown status
    - Always prunes failed holepunch attempts (PathStatus::Unusable)
    - Keeps 10 most recently inactive paths that were previously successful
- Special case: if all paths failed, keeps `MAX_IP_PATHS` instead of pruning everything
- Added tests for edge cases and the typical case

Author: ramfox

iroh/src/magicsock/remote_map.rs

@@ -185,11 +185,6 @@ pub enum Source {
         _0: Private,
     },
     /// We established a connection on this address.
-    ///
-    /// Currently this means the path was in uses as [`PathId::ZERO`] when the a connection
-    /// was added to the `RemoteStateActor`.
-    ///
-    /// [`PathId::ZERO`]: quinn_proto::PathId::ZERO
     #[strum(serialize = "Connection")]
     Connection {
         /// private marker

iroh/src/magicsock/remote_map/remote_state.rs

@@ -50,16 +50,6 @@ const HOLEPUNCH_ATTEMPTS_INTERVAL: Duration = Duration::from_secs(5);
 mod guarded_channel;
 mod path_state;
 
-// TODO: use this
-// /// Number of addresses that are not active that we keep around per endpoint.
-// ///
-// /// See [`RemoteState::prune_direct_addresses`].
-// pub(super) const MAX_INACTIVE_DIRECT_ADDRESSES: usize = 20;
-
-// TODO: use this
-// /// How long since an endpoint path was last alive before it might be pruned.
-// const LAST_ALIVE_PRUNE_DURATION: Duration = Duration::from_secs(120);
-
 // TODO: use this
 // /// The latency at or under which we don't try to upgrade to a better path.
 // const GOOD_ENOUGH_LATENCY: Duration = Duration::from_millis(5);
@@ -461,7 +451,7 @@ impl RemoteStateActor {
                 path.set_status(status).ok();
                 conn_state.add_open_path(path_remote.clone(), PathId::ZERO);
                 self.paths
-                    .insert(path_remote, Source::Connection { _0: Private });
+                    .insert_open_path(path_remote.clone(), Source::Connection { _0: Private });
                 self.select_path();
 
                 if path_remote_is_ip {
@@ -779,15 +769,17 @@ impl RemoteStateActor {
                     );
                     conn_state.add_open_path(path_remote.clone(), path_id);
                     self.paths
-                        .insert(path_remote, Source::Connection { _0: Private });
+                        .insert_open_path(path_remote.clone(), Source::Connection { _0: Private });
                 }
 
                 self.select_path();
             }
             PathEvent::Abandoned { id, path_stats } => {
                 trace!(?path_stats, "path abandoned");
                 // This is the last event for this path.
-                conn_state.remove_path(&id);
+                if let Some(addr) = conn_state.remove_path(&id) {
+                    self.paths.abandoned_path(&addr);
+                }
             }
             PathEvent::Closed { id, .. } | PathEvent::LocallyClosed { id, .. } => {
                 let Some(path_remote) = conn_state.paths.get(&id).cloned() else {
@@ -1073,11 +1065,13 @@ impl ConnectionState {
     }
 
     /// Completely removes a path from this connection.
-    fn remove_path(&mut self, path_id: &PathId) {
-        if let Some(addr) = self.paths.remove(path_id) {
-            self.path_ids.remove(&addr);
+    fn remove_path(&mut self, path_id: &PathId) -> Option<transports::Addr> {
+        let addr = self.paths.remove(path_id);
+        if let Some(ref addr) = addr {
+            self.path_ids.remove(addr);
         }
         self.open_paths.remove(path_id);
+        addr
     }
 
     /// Removes the path from the open paths.