Small refactoring of `Canonical` — heartwood

The Canonical type is generally constructed with the threshold, needed for the quorum computation, in scope. To make it easier to use and encapsulate its functionality, it now holds the threshold as an additional field.

Changes for the Canonical type:

Reorder arguments so that delegates and threshold are grouped after refname
Add Canonical::is_empty to detect when Canonical was constructed with no tips
Consume Canonical when calling Canonical::quorum to indicate that it should be the final step

                                 stored,
                                 &project,
                                 identity.delegates().as_ref(),
                                 identity.threshold(),
                             )?;
                             let converges = canonical::converges(
                                 canonical

                                 canonical.modify_vote(me, head.into());
                             }
                             match canonical.quorum(identity.threshold(), &working) {
                             match canonical.quorum(&working) {
                                 Ok(canonical_oid) => {
                                     // Canonical head is an ancestor of head.
                                     let is_ff = head == *canonical_oid

 ///
 /// `Canonical` can then be used for performing calculations about the
 /// canonicity of the reference, most importantly the [`Canonical::quorum`].
 #[derive(Debug)]
 pub struct Canonical {
     tips: BTreeMap<Did, Oid>,
     threshold: usize,
 }
 /// Error that can occur when calculation the [`Canonical::quorum`].

         repo: &S,
         project: &Project,
         delegates: &NonEmpty<Did>,
         threshold: usize,
     ) -> Result<Self, raw::Error>
     where
         S: ReadRepository,
     {
         Self::reference(
             repo,
             delegates,
             &lit::refs_heads(project.default_branch()).into(),
             delegates,
             threshold,
         )
     }

     /// the reference `name`.
     pub fn reference<S>(
         repo: &S,
         refname: &Qualified,
         delegates: &NonEmpty<Did>,
         name: &Qualified,
         threshold: usize,
     ) -> Result<Self, raw::Error>
     where
         S: ReadRepository,
     {
         let mut tips = BTreeMap::new();
         for delegate in delegates.iter() {
             match repo.reference_oid(delegate, name) {
             match repo.reference_oid(delegate, refname) {
                 Ok(tip) => {
                     tips.insert(*delegate, tip);
                 }
                 Err(e) if super::ext::is_not_found_err(&e) => {
                     log::warn!(
                         target: "radicle",
                         "Missing `refs/namespaces/{}/{name}` while calculating the canonical reference",
                         "Missing `refs/namespaces/{}/{refname}` while calculating the canonical reference",
                         delegate.as_key()
                     );
                 }
                 Err(e) => return Err(e),
             }
         }
         Ok(Canonical { tips })
         Ok(Canonical { tips, threshold })
     }
     /// Return the set of [`Did`]s and their [`Oid`] tip.
     pub fn tips(&self) -> impl Iterator<Item = (&Did, &Oid)> {
         self.tips.iter()
     }
     /// Returns `true` is there were no tips found for any of the delegates for
     /// the given reference.
     ///
     /// N.b. this may be the case when a new reference is being created.
     pub fn is_empty(&self) -> bool {
         self.tips.is_empty()
     }
 }
 /// Check that a given `target` converges with any of the provided `tips`.

     ///
     /// Also returns an error if `heads` is empty or `threshold` cannot be
     /// satisified with the number of heads given.
     pub fn quorum(&self, threshold: usize, repo: &raw::Repository) -> Result<Oid, QuorumError> {
     pub fn quorum(self, repo: &raw::Repository) -> Result<Oid, QuorumError> {
         let mut candidates = BTreeMap::<_, usize>::new();
         // Build a list of candidate commits and count how many "votes" each of them has.

             }
         }
         // Keep commits which pass the threshold.
         candidates.retain(|_, votes| *votes >= threshold);
         candidates.retain(|_, votes| *votes >= self.threshold);
         let (mut longest, _) = candidates
             .pop_first()
             .ok_or(QuorumError::NoCandidates(NoCandidates { threshold }))?;
         let (mut longest, _) =
             candidates
                 .pop_first()
                 .ok_or(QuorumError::NoCandidates(NoCandidates {
                     threshold: self.threshold,
                 }))?;
         // Now that all scores are calculated, figure out what is the longest branch
         // that passes the threshold. In case of divergence, return an error.

                 (did, (*head).into())
             })
             .collect();
         Canonical { tips }.quorum(threshold, repo)
         Canonical { tips, threshold }.quorum(repo)
     }
     #[test]

         let project = doc.project()?;
         let branch_ref = git::refs::branch(project.default_branch());
         let raw = self.raw();
         let oid = Canonical::default_branch(self, &project, doc.delegates().into())?
             .quorum(doc.threshold(), raw)?;
         let oid =
             Canonical::default_branch(self, &project, doc.delegates().into(), doc.threshold())?
                 .quorum(raw)?;
         Ok((branch_ref, oid))
     }