Perform `git gc` on an interval basis — heartwood

Instead of performing a git gc on every fetch, do it on an interval basis.

         "inbound": 128,
         "outbound": 16
       },
       "gcInterval": 600,
       "fetchPackReceive": "500.0 MiB"
     },
     "workers": 8,

             limit: FetchLimit::default(),
             local: nid,
             expiry: worker::garbage::Expiry::default(),
             gc_interval: config.limits.gc_interval.into(),
         };
         let pool = worker::Pool::with(
             worker_recv,

 pub mod fetch;
 pub mod garbage;
 use std::collections::HashMap;
 use std::path::PathBuf;
 use crossbeam_channel as chan;

 use crate::runtime::{thread, Handle};
 use crate::wire::StreamId;
 use crate::{LocalDuration, LocalTime};
 pub use channels::{ChannelEvent, Channels, ChannelsConfig};

     /// Configuration for `git gc` garbage collection. Defaults to `1
     /// hour ago`.
     pub expiry: garbage::Expiry,
     /// Minimum interval between `git gc` runs per repository.
     pub gc_interval: LocalDuration,
 }
 /// A worker that replicates git objects.

     notifications: notifications::StoreWriter,
     cache: cob::cache::StoreWriter,
     db: radicle::node::Database,
     last_gc: HashMap<RepoId, LocalTime>,
 }
 impl Worker {

             limit,
             local,
             expiry,
             gc_interval,
         } = &self.fetch_config;
         // N.b. if the `rid` is blocked this will return an error, so
         // we won't continue with any further set up of the fetch.

             refs_at,
         )?;
         if let Err(e) = garbage::collect(&self.storage, rid, *expiry) {
             // N.b. ensure that `git gc` works in debug mode.
             debug_assert!(false, "`git gc` failed: {e}");
             log::debug!(target: "worker", "Failed to run `git gc`: {e}");
         let now = LocalTime::now();
         let should_gc = self
             .last_gc
             .get(&rid)
             .map(|last| now - *last >= *gc_interval)
             .unwrap_or(true);
         if should_gc {
             if let Err(e) = garbage::collect(&self.storage, rid, *expiry) {
                 // N.b. ensure that `git gc` works in debug mode.
                 debug_assert!(false, "`git gc` failed: {e}");
                 log::debug!(target: "worker", "Failed to run `git gc`: {e}");
             }
             self.last_gc.insert(rid, now);
         } else {
             log::debug!(target: "worker", "Skipping `git gc` for {rid}; recently ran");
         }
         Ok(result)
     }

                 notifications: notifications.clone(),
                 cache: cache.clone(),
                 db: db.clone(),
                 last_gc: HashMap::new(),
             };
             let thread = thread::spawn(&nid, format!("worker#{i}"), || worker.run());

     /// Connection limits.
     pub connection: ConnectionLimits,
     /// Minimum interval between `git gc` runs per repository.
     pub gc_interval: LimitGcInterval,
     /// Channel limits.
     pub fetch_pack_receive: FetchPackSizeLimit,
 }

     }
 }
 #[derive(Clone, Copy, Debug, Deserialize, Serialize, Eq, PartialEq)]
 #[serde(transparent)]
 #[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct LimitGcInterval(localtime::LocalDuration);
 impl Default for LimitGcInterval {
     fn default() -> Self {
         Self(localtime::LocalDuration::from_mins(10))
     }
 }
 impl From<LimitGcInterval> for LocalDuration {
     fn from(value: LimitGcInterval) -> Self {
         value.0
     }
 }
 impl From<LocalDuration> for LimitGcInterval {
     fn from(value: LocalDuration) -> Self {
         Self(value)
     }
 }
 /// Create a new type (`$name`) around a given type (`$type`), with a provided
 /// default (`$default`).
 ///