Draft: Implement a retry-after-delay mechanism for FallbackDirs

Similar to the behavior of guards, we now penalize FallbackDirs when they give us invalid information, and don't try them again for a while.

This approach still needs fine-tuning, and parts of the code are a bit unsightly. It marginally improves our behavior under some circumstances for #329 (closed), though, and enables further efficiency improvements.

---

edited to add:

I can confirm that this resolves #406 (closed). Previous behavior was:

TCP stats: TcpCount { n_connect_attempt: 2140, n_connect_ok: 2140, n_accept: 0, n_bytes_send: 2446020, n_bytes_recv: 7411362 }
Total events: Trace: 25698, Debug: 3680, Info: 4206, Warn: 26, Error: 0

With this branch:

TCP stats: TcpCount { n_connect_attempt: 10, n_connect_ok: 10, n_accept: 0, n_bytes_send: 11430, n_bytes_recv: 34754 }
Total events: Trace: 128, Debug: 38, Info: 33, Warn: 1, Error: 0

So: Closes #406 (closed).

crates/tor-circmgr/src/build/guardstatus.rs

-//! Helpers for reporting information about guard status to the guard manager.
+//! Helpers for reporting information about first-hop status.
 
+use crate::fallback::FallbackMonitor;
 use std::sync::Mutex;
 use tor_guardmgr::{GuardMonitor, GuardStatus};
 
 /// A shareable object that we can use to report guard status to the guard
-/// manager.
-pub(crate) struct GuardStatusHandle {
-    /// An inner guard monitor.
+/// manager or fallback list.
+///
+/// See [`GuardMonitor`] for more information about usage here.
+pub struct FirstHopStatusHandle {
+    /// An inner guard or fallback monitor.
     ///
     /// If this is None, then either we aren't using the guard
     /// manager, or we already reported a status to it.
-    mon: Mutex<Option<GuardMonitor>>,
+    mon: Mutex<Option<Inner>>,
+}
+
+/// An enum holding the actual monitor object.
+enum Inner {
+    /// An inner guard monitor.
+    Guard(GuardMonitor),
+
+    /// An inner fallback monitor.
+    Fallback(FallbackMonitor),
 }
 
-impl From<Option<GuardMonitor>> for GuardStatusHandle {
+impl From<Option<GuardMonitor>> for FirstHopStatusHandle {
     fn from(mon: Option<GuardMonitor>) -> Self {
         Self {
-            mon: Mutex::new(mon),
+            mon: Mutex::new(mon.map(Inner::Guard)),
+        }
+    }
+}
+
+impl From<FallbackMonitor> for FirstHopStatusHandle {
+    fn from(mon: FallbackMonitor) -> Self {
+        Self {
+            mon: Mutex::new(Some(Inner::Fallback(mon))),
+        }
+    }
+}
+
+impl Inner {
+    /// Commit the pending status from this monitor.
+    fn commit(self) {
+        match self {
+            Inner::Guard(m) => m.commit(),
+            Inner::Fallback(m) => m.commit(),
+        }
+    }
+    /// Report a pending status to this monitor.
+    fn pending_status(&mut self, status: GuardStatus) {
+        match self {
+            Inner::Guard(m) => m.pending_status(status),
+            Inner::Fallback(m) => m.pending_status(status),
+        }
+    }
+    /// Report a given status to this monitor.
+    fn report(self, status: GuardStatus) {
+        match self {
+            Inner::Guard(m) => m.report(status),
+            Inner::Fallback(m) => m.report(status),
         }
     }
 }
 
-impl GuardStatusHandle {
+impl FirstHopStatusHandle {
     /// Finalize this guard status handle, and report its pending status
     /// to the guard manager.
     ///