Fix preferred seeds configuration — heartwood

When using network: "test", we shouldn’t default to any public seed node. This change makes sure that the “preferredSeeds” configuration var is only given a value when network is main.

 $ rad config
 {
   "publicExplorer": "https://app.radicle.xyz/nodes/$host/$rid$path",
   "preferredSeeds": [],
   "preferredSeeds": [
     "z6MkrLMMsiPWUcNPHcRajuMi9mDfYckSoJyPwwnknocNYPm7@seed.radicle.garden:8776"
   ],
   "web": {
     "pinned": {
       "repositories": []
     }
   },
   "cli": {
     "hints": false
     "hints": true
   },
   "node": {
     "alias": "alice",

     },
     "connect": [],
     "externalAddresses": [],
     "network": "test",
     "network": "main",
     "relay": true,
     "limits": {
       "routingMaxSize": 1000,

 use radicle::node::{Alias, DEFAULT_TIMEOUT};
 use radicle::prelude::RepoId;
 use radicle::profile;
 use radicle::profile::{Home, PreferredSeeds};
 use radicle::profile::Home;
 use radicle::storage::{ReadStorage, RemoteRepository};
 use radicle::test::fixtures;

 #[test]
 fn rad_config() {
     let mut environment = Environment::new();
     let profile = environment.profile(config::profile("alice"));
     let alias = Alias::new("alice");
     let profile = environment.profile(profile::Config::new(alias));
     let working = tempfile::tempdir().unwrap();
     test(

         .spawn();
     let bob = environment.profile(profile::Config {
         preferred_seeds: PreferredSeeds::from(vec![alice.address()]),
         preferred_seeds: vec![alice.address()],
         ..config::profile("bob")
     });
     let mut bob = Node::new(bob).spawn();

 use radicle::node::{Alias, POLICIES_DB_FILE};
 use radicle::node::{ConnectOptions, Handle as _};
 use radicle::profile;
 use radicle::profile::{Home, PreferredSeeds, Profile};
 use radicle::profile::{Home, Profile};
 use radicle::rad;
 use radicle::storage::{ReadStorage as _, RemoteRepository as _, SignRepository as _};
 use radicle::test::fixtures;

             node: node::Config::test(alias),
             cli: cli::Config { hints: false },
             public_explorer: explorer::Explorer::default(),
             preferred_seeds: PreferredSeeds::from(vec![]),
             preferred_seeds: vec![],
             web: web::Config::default(),
         }
     }

 pub enum Source {
     /// An address that was shared by another peer.
     Peer,
     /// An bootstrap node address.
     /// A bootstrap node address.
     Bootstrap,
     /// An address that came from some source external to the system, eg.
     /// specified by the user or added directly to the address manager.

             Self::Test => vec![],
         }
     }
     /// Public seeds for this network.
     pub fn public_seeds(&self) -> Vec<ConnectAddress> {
         match self {
             Self::Main => vec![seeds::RADICLE_COMMUNITY_NODE.clone()],
             Self::Test => vec![],
         }
     }
 }
 /// Configuration parameters defining attributes of minima and maxima.

 use std::path::{Path, PathBuf};
 use std::{fs, io, str::FromStr};
 use serde::{Deserialize, Serialize};
 use serde::Serialize;
 use thiserror::Error;
 use crate::crypto::ssh::agent::Agent;

     /// Preferred seeds. These seeds will be used for explorer links
     /// and in other situations when a seed needs to be chosen.
     #[serde(default)]
     pub preferred_seeds: PreferredSeeds,
     pub preferred_seeds: Vec<node::config::ConnectAddress>,
     /// Web configuration.
     #[serde(default)]
     pub web: web::Config,

 impl Config {
     /// Create a new, default configuration.
     pub fn new(alias: Alias) -> Self {
         let node = node::Config::new(alias);
         Self {
             public_explorer: Explorer::default(),
             preferred_seeds: PreferredSeeds::default(),
             preferred_seeds: node.network.public_seeds(),
             web: web::Config::default(),
             cli: cli::Config::default(),
             node: node::Config::new(alias),
             node,
         }
     }

     }
 }
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(transparent)]
 pub struct PreferredSeeds(Vec<node::config::ConnectAddress>);
 impl From<Vec<node::config::ConnectAddress>> for PreferredSeeds {
     fn from(value: Vec<node::config::ConnectAddress>) -> Self {
         Self(value)
     }
 }
 impl Default for PreferredSeeds {
     fn default() -> Self {
         Self(vec![node::config::seeds::RADICLE_COMMUNITY_NODE.clone()])
     }
 }
 impl std::ops::Deref for PreferredSeeds {
     type Target = Vec<node::config::ConnectAddress>;
     fn deref(&self) -> &Self::Target {
         &self.0
     }
 }
 #[derive(Debug, Clone)]
 pub struct Profile {
     pub home: Home,