cli: Add `--from` and other options to `rad seed` — heartwood

Gives the same options to rad seed as rad sync --fetch.

Allows seeding and syncing from specific seeds in one command:

rad seed –from

Useful for seeding private repos on public nodes.

 ╰────────────────────────────────────╯
 Run `cd ./heartwood` to go to the repository directory.
 ```
 We can also use `rad seed` to seed and fetch without creating a checkout.
 ``` ~bob
 $ rad seed rad:z2ug5mwNKZB8KGpBDRTrWHAMbvHCu --from z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi --timeout 1
 ✓ Seeding policy exists for rad:z2ug5mwNKZB8KGpBDRTrWHAMbvHCu with scope 'all'
 ✓ Fetching rad:z2ug5mwNKZB8KGpBDRTrWHAMbvHCu from z6MknSL…StBU8Vi..
 ```

 use std::collections::BTreeSet;
 use std::ffi::OsString;
 use std::time;
 use anyhow::anyhow;

     usage: r#"
 Usage
     rad seed [<rid>] [--[no-]fetch] [--scope <scope>] [<option>...]
     rad seed [<rid>] [--[no-]fetch] [--from <nid>] [--scope <scope>] [<option>...]
     The `seed` command, when no Repository ID (<rid>) is provided, will list the
     repositories being seeded.

 Options
     --[no-]fetch           Fetch repository after updating seeding policy
     --from <nid>           Fetch from the given node (may be specified multiple times)
     --timeout <secs>       Fetch timeout in seconds (default: 9)
     --scope <scope>        Peer follow scope for this repository
     --verbose, -v          Verbose output
     --help                 Print help

     Seed {
         rid: RepoId,
         fetch: bool,
         seeds: BTreeSet<NodeId>,
         timeout: time::Duration,
         scope: Scope,
     },
     List,

         let mut rid: Option<RepoId> = None;
         let mut scope: Option<Scope> = None;
         let mut fetch: Option<bool> = None;
         let mut timeout = time::Duration::from_secs(9);
         let mut seeds: BTreeSet<NodeId> = BTreeSet::new();
         let mut verbose = false;
         while let Some(arg) = parser.next()? {

                 Long("no-fetch") => {
                     fetch = Some(false);
                 }
                 Long("from") => {
                     let val = parser.value()?;
                     let nid = term::args::nid(&val)?;
                     seeds.insert(nid);
                 }
                 Long("timeout") | Short('t') => {
                     let value = parser.value()?;
                     let secs = term::args::parse_value("timeout", value)?;
                     timeout = time::Duration::from_secs(secs);
                 }
                 Long("verbose") | Short('v') => verbose = true,
                 Long("help") | Short('h') => {
                     return Err(Error::Help.into());

                 rid,
                 fetch: fetch.unwrap_or(true),
                 scope: scope.unwrap_or(Scope::All),
                 timeout,
                 seeds,
             },
             None => Operation::List,
         };

     let mut node = radicle::Node::new(profile.socket());
     match options.op {
         Operation::Seed { rid, fetch, scope } => {
         Operation::Seed {
             rid,
             fetch,
             scope,
             timeout,
             seeds,
         } => {
             update(rid, scope, &mut node, &profile)?;
             if fetch && node.is_running() {
                 sync::fetch(
                     rid,
                     SyncSettings::default().with_profile(&profile),
                     SyncSettings::default()
                         .seeds(seeds)
                         .timeout(timeout)
                         .with_profile(&profile),
                     &mut node,
                 )?;
             }

         self
     }
     /// Set seeds.
     pub fn seeds(mut self, seeds: impl IntoIterator<Item = NodeId>) -> Self {
         self.seeds = seeds.into_iter().collect();
         self
     }
     /// Use profile to populate sync settings, by adding preferred seeds if no seeds are specified,
     /// and removing the local node from the set.
     pub fn with_profile(mut self, profile: &Profile) -> Self {