docs: fix unresolved rustdoc links + rustfmt reflow

Three rustdoc warnings:
- `SelectionView` referenced the pub(crate) `crate::bnb::BnbIter` in
  prose. Reworded to describe the behaviour without naming the internal
  type.
- `Drain` linked to `CoinSelector::drain`, which moved to
  `SelectionView::drain`. Retargeted.
- `metrics` module docs used `[CoinSelector::run_bnb]` / `bnb_solutions`
  with no `use` in module scope. Switched to fully-qualified
  `crate::CoinSelector::...` paths.

Also picks up rustfmt reflows across the changed files.

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

Author: evanlinjin

src/bnb.rs

@@ -1,17 +1,12 @@
 //! Branch-and-bound search.
 //!
-//! BnB explores a binary tree where each [`Branch`] expands into two
-//! children: an *inclusion* child that selects the candidate at the
-//! branch's `cursor`, and an *exclusion* child that bans it along with
-//! any same-(value, weight) duplicates that immediately follow.
+//! BnB explores a binary tree where each [`Branch`] expands into two children: an *inclusion*
+//! child that selects the candidate at the branch's `cursor`, and an *exclusion* child that bans
+//! it along with any same-(value, weight) duplicates that immediately follow.
 //!
-//! Cursors only advance as we descend — inclusion's child has cursor
-//! `parent + 1`; exclusion's jumps past the banned duplicates. That
-//! invariant lets `insert_new_branches` skip directly to the next
-//! undecided candidate without re-scanning `selected` / `banned`. The
-//! only scanning happens to step past pre-selected / pre-banned positions
-//! (rare, lazy).
-
+//! Cursors only advance as we descend — inclusion's child has cursor `parent + 1`; exclusion's
+//! jumps past the banned duplicates. That invariant lets `insert_new_branches` skip directly to the
+//! next undecided candidate without re-scanning `selected` / `banned` from the start.
 use core::cmp::Reverse;
 
 use crate::{float::Ordf32, Drain, SelectionCache, SelectionView, Target};
@@ -97,7 +92,9 @@ impl<'a, M: BnbMetric> BnbIter<'a, M> {
         is_exclusion: bool,
         cursor: usize,
     ) {
-        let bound = self.metric.bound(&SelectionView::with_cache(cs, cache), self.target);
+        let bound = self
+            .metric
+            .bound(&SelectionView::with_cache(cs, cache), self.target);
         if let Some(bound) = bound {
             let is_good_enough = match self.best {
                 Some(best) => best > bound,
@@ -115,16 +112,10 @@ impl<'a, M: BnbMetric> BnbIter<'a, M> {
         }
     }
 
-    fn insert_new_branches(
-        &mut self,
-        cs: &CoinSelector<'a>,
-        cache: &SelectionCache,
-        start: usize,
-    ) {
-        // Find the position to expand on: at or after `start`, whichever is
-        // the first candidate that's neither selected nor banned. Usually
-        // this *is* `start` — the only reason to advance is to skip past
-        // pre-selected/pre-banned candidates (see module-level docs).
+    fn insert_new_branches(&mut self, cs: &CoinSelector<'a>, cache: &SelectionCache, start: usize) {
+        // Find the position to expand on: at or after `start`, whichever is the first candidate
+        // that's neither selected nor banned. Usually this *is* `start` — the only reason to
+        // advance is to skip past pre-selected/pre-banned candidates (see module-level docs).
         let mut iter = cs.candidates().skip(start);
         let mut cursor = start;
         let (here_idx, here_cand) = loop {
@@ -147,10 +138,9 @@ impl<'a, M: BnbMetric> BnbIter<'a, M> {
         inclusion_cache.add(here_cand);
         self.consider_adding_to_queue(&inclusion_cs, &inclusion_cache, false, cursor + 1);
 
-        // Exclusion: descendants explore "this candidate is *not* selected".
-        // Bans this and every consecutive same-(value, weight) candidate —
-        // they're equivalent choices, so we deduplicate by handling the
-        // entire equivalence class in one branch. The cursor jumps past
+        // Exclusion: descendants explore "this candidate is *not* selected". Bans this and every
+        // consecutive same-(value, weight) candidate — they're equivalent choices, so we
+        // deduplicate by handling the entire equivalence class in one branch. The cursor jumps past
         // all of them.
         let mut exclusion_cs = cs.clone();
         exclusion_cs.ban(here_idx);
@@ -173,9 +163,8 @@ struct Branch<'a> {
     selector: CoinSelector<'a>,
     cache: SelectionCache,
     is_exclusion: bool,
-    /// Position in `candidate_order` of the candidate whose include /
-    /// exclude decision creates this branch's two children. See the
-    /// module-level "Cursor invariant" section.
+    /// Position in `candidate_order` of the candidate whose include/exclude decision creates this
+    /// branch's two children. See the module-level docs for more.
     cursor: usize,
 }
 

src/coin_selector.rs

@@ -244,7 +244,10 @@ impl<'a> CoinSelector<'a> {
     pub fn select_until_target_met(&mut self, target: Target) -> Result<(), InsufficientFunds> {
         self.select_until(|cs| cs.compute_view().is_target_met(target))
             .ok_or_else(|| InsufficientFunds {
-                missing: self.compute_view().excess(target, Drain::NONE).unsigned_abs(),
+                missing: self
+                    .compute_view()
+                    .excess(target, Drain::NONE)
+                    .unsigned_abs(),
             })
     }
 

src/drain.rs

@@ -70,10 +70,10 @@ impl DrainWeights {
 /// A drain (A.K.A. change) output.
 /// Technically it could represent multiple outputs.
 ///
-/// This is returned from [`CoinSelector::drain`]. Note if `drain` returns a drain where `is_none()`
-/// returns true then **no change should be added** to the transaction.
+/// This is returned from [`SelectionView::drain`]. Note if `drain` returns a drain where
+/// `is_none()` returns true then **no change should be added** to the transaction.
 ///
-/// [`CoinSelector::drain`]: crate::CoinSelector::drain
+/// [`SelectionView::drain`]: crate::SelectionView::drain
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Default)]
 pub struct Drain {
     /// Weight of adding drain output and spending the drain output.

src/lib.rs

@@ -17,8 +17,8 @@ mod coin_selector;
 pub mod float;
 pub use coin_selector::*;
 mod selection_view;
-pub use selection_view::SelectionView;
 use selection_view::SelectionCache;
+pub use selection_view::SelectionView;
 
 mod bnb;
 pub use bnb::*;

src/selection_view.rs

@@ -47,7 +47,11 @@ impl SelectionCache {
         let is_segwit_tx = self.segwit_count > 0;
         let witness_header_extra_weight = is_segwit_tx as u64 * 2;
         let nonsegwit_count = self.candidate_count - self.segwit_count;
-        let segwit_adjust = if is_segwit_tx { nonsegwit_count as u64 } else { 0 };
+        let segwit_adjust = if is_segwit_tx {
+            nonsegwit_count as u64
+        } else {
+            0
+        };
         let input_varint_weight = varint_size(self.input_count) * 4;
         input_varint_weight + self.weight_sum + segwit_adjust + witness_header_extra_weight
     }
@@ -84,9 +88,9 @@ impl SelectionCache {
 /// [`BnbMetric::bound`](crate::BnbMetric::bound) in the BnB hot path.
 ///
 /// Methods on this type read pre-computed aggregates rather than walking the
-/// selected bitset, so they are constant-time. The cache is maintained
-/// incrementally by [`crate::bnb::BnbIter`], which is what makes the metric
-/// evaluator "delta-aware".
+/// selected bitset, so they are constant-time. During branch-and-bound
+/// search, the cache is maintained incrementally as branches are explored,
+/// which is what makes the metric evaluator "delta-aware".
 ///
 /// `SelectionView` implements [`Deref<Target = CoinSelector>`](Deref), so every
 /// `&self` method of [`CoinSelector`] is reachable directly on the view.
@@ -108,10 +112,7 @@ impl<'a> Deref for SelectionView<'a> {
 impl<'a> SelectionView<'a> {
     /// Construct a view that borrows an externally maintained cache. Caller is
     /// responsible for keeping the cache in sync with `selector`'s selection.
-    pub(crate) fn with_cache(
-        selector: &'a CoinSelector<'a>,
-        cache: &'a SelectionCache,
-    ) -> Self {
+    pub(crate) fn with_cache(selector: &'a CoinSelector<'a>, cache: &'a SelectionCache) -> Self {
         Self {
             selector,
             cache: Cow::Borrowed(cache),
@@ -316,7 +317,11 @@ impl<'a> SelectionView<'a> {
     /// the larger of the two.
     pub fn implied_fee(&self, target: Target, drain_weights: DrainWeights) -> u64 {
         let tx_weight = self.weight(target.outputs, drain_weights);
-        let mut implied_fee = target.fee.rate.implied_fee(tx_weight).max(target.fee.absolute);
+        let mut implied_fee = target
+            .fee
+            .rate
+            .implied_fee(tx_weight)
+            .max(target.fee.absolute);
         if let Some(replace) = target.fee.replace {
             implied_fee = Ord::max(implied_fee, replace.min_fee_to_do_replacement(tx_weight));
         }
@@ -328,11 +333,7 @@ impl<'a> SelectionView<'a> {
     /// telling you what target feerate you currently have.
     ///
     /// Returns `None` if the feerate would be negative or infinity.
-    pub fn implied_feerate(
-        &self,
-        target_outputs: TargetOutputs,
-        drain: Drain,
-    ) -> Option<FeeRate> {
+    pub fn implied_feerate(&self, target_outputs: TargetOutputs, drain: Drain) -> Option<FeeRate> {
         let numerator =
             self.selected_value() as i64 - target_outputs.value_sum as i64 - drain.value as i64;
         let denom = self.weight(target_outputs, drain.weights);

tests/bnb.rs

@@ -106,7 +106,12 @@ fn bnb_finds_an_exact_solution_in_n_iter() {
     assert_eq!(rounds, 3194);
     let best_view = best.compute_view();
     assert_eq!(best_view.input_weight(), solution_weight);
-    assert_eq!(best_view.selected_value(), target_value, "score={:?}", score);
+    assert_eq!(
+        best_view.selected_value(),
+        target_value,
+        "score={:?}",
+        score
+    );
 }
 
 #[test]

tests/common.rs

@@ -171,10 +171,12 @@ where
                 .flatten()
                 .filter(|(_, inc)| *inc)
             {
-                if let Some(descendant_score) = metric.score(&descendant_cs.compute_view(), target) {
+                if let Some(descendant_score) = metric.score(&descendant_cs.compute_view(), target)
+                {
                     let parent_has_change = metric.drain(&cs.compute_view(), target).is_some();
-                    let descendant_has_change =
-                        metric.drain(&descendant_cs.compute_view(), target).is_some();
+                    let descendant_has_change = metric
+                        .drain(&descendant_cs.compute_view(), target)
+                        .is_some();
                     prop_assert!(
                         descendant_score >= lb_score,
                         "
@@ -351,7 +353,11 @@ where
         .enumerate()
         .inspect(|(i, _)| rounds = *i)
         .filter(|(_, (_, inclusion))| *inclusion)
-        .filter_map(|(_, (cs, _))| metric.score(&cs.compute_view(), target).map(|score| (cs, score)));
+        .filter_map(|(_, (cs, _))| {
+            metric
+                .score(&cs.compute_view(), target)
+                .map(|score| (cs, score))
+        });
 
     for (child_cs, score) in iter {
         match &mut best {