cli: Move node addresses command — heartwood

To make things a little more consistent, move the rad self --address command to rad node config --addresses, since it’s more about externally-facing configuration of the node, rather than your local user or profile.

 ✓ Node is running and listening on [..].
 ```
 ```
 $ rad node config --addresses
 z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi@41.12.98.112:8776
 z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi@seed.cloudhead.io:8776
 ```
 The node also allows us to query data that it has access to such as
 the follow policies and the routing table. Before we explore
 those commands we'll first follow a peer so that we have something to

 $ rad self --home
 [..]/home/alice/.radicle
 ```
 ```
 $ rad self --address
 z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi@seed.alice.acme:8776
 ```

 use anyhow::anyhow;
 use radicle::node::config::ConnectAddress;
 use radicle::node::Handle as _;
 use radicle::node::{Address, Node, NodeId, PeerAddr};
 use radicle::prelude::RepoId;

     rad node connect <nid>@<addr> [<option>...]
     rad node routing [--rid <rid>] [--nid <nid>] [--json] [<option>...]
     rad node events [--timeout <secs>] [-n <count>] [<option>...]
     rad node config
     rad node config [--addresses]
     For `<node-option>` see `radicle-node --help`.

         addr: PeerAddr<NodeId, Address>,
         timeout: time::Duration,
     },
     Config,
     Config {
         addresses: bool,
     },
     Events {
         timeout: time::Duration,
         count: usize,

         let mut lines: usize = 60;
         let mut count: usize = usize::MAX;
         let mut timeout = time::Duration::MAX;
         let mut addresses = false;
         let mut path = None;
         let mut verbose = false;

                 Long("foreground") if matches!(op, Some(OperationName::Start)) => {
                     foreground = true;
                 }
                 Long("addresses") if matches!(op, Some(OperationName::Config)) => {
                     addresses = true;
                 }
                 Long("verbose") | Short('v') if matches!(op, Some(OperationName::Start)) => {
                     verbose = true;
                 }

                 })?,
                 timeout,
             },
             OperationName::Config => Operation::Config,
             OperationName::Config => Operation::Config { addresses },
             OperationName::Events => Operation::Events { timeout, count },
             OperationName::Routing => Operation::Routing { rid, nid, json },
             OperationName::Logs => Operation::Logs { lines },

         Operation::Connect { addr, timeout } => {
             control::connect(&mut node, addr.id, addr.addr, timeout)?
         }
         Operation::Config => control::config(&node)?,
         Operation::Config { addresses } => {
             if addresses {
                 let cfg = node.config()?;
                 for addr in cfg.external_addresses {
                     term::print(ConnectAddress::from((*profile.id(), addr)).to_string());
                 }
             } else {
                 control::config(&node)?;
             }
         }
         Operation::Sessions => {
             let sessions = control::sessions(&node)?;
             if let Some(table) = sessions {

 use std::ffi::OsString;
 use radicle::crypto::ssh;
 use radicle::node::config::ConnectAddress;
 use radicle::Profile;
 use crate::terminal as term;

     --did                Show your DID
     --alias              Show your Node alias
     --nid                Show your Node ID (NID)
     --address            Show your Node address(es)
     --home               Show your Radicle home
     --config             Show the location of your configuration file
     --ssh-key            Show your public key in OpenSSH format

 #[derive(Debug)]
 enum Show {
     Alias,
     Address,
     NodeId,
     Did,
     Home,

                 Long("alias") if show.is_none() => {
                     show = Some(Show::Alias);
                 }
                 Long("address") if show.is_none() => {
                     show = Some(Show::Address);
                 }
                 Long("nid") if show.is_none() => {
                     show = Some(Show::NodeId);
                 }

         Show::Alias => {
             term::print(profile.config.alias());
         }
         Show::Address => {
             let nid = profile.public_key;
             for addr in profile.config.node.external_addresses {
                 term::print(ConnectAddress::from((nid, addr)).to_string());
             }
         }
         Show::NodeId => {
             term::print(profile.id());
         }

 use std::path::Path;
 use std::str::FromStr;
 use std::{env, thread, time};
 use std::{env, net, thread, time};
 use radicle::git;
 use radicle::node;

 use radicle::node::config::seeds::{RADICLE_COMMUNITY_NODE, RADICLE_TEAM_NODE};
 use radicle::node::routing::Store as _;
 use radicle::node::Handle as _;
 use radicle::node::{Alias, DEFAULT_TIMEOUT};
 use radicle::node::{Address, Alias, DEFAULT_TIMEOUT};
 use radicle::prelude::RepoId;
 use radicle::profile;
 use radicle::profile::Home;

 #[test]
 fn rad_node() {
     let mut environment = Environment::new();
     let alice = environment.node(Config::test(Alias::new("alice")));
     let alice = environment.node(Config {
         external_addresses: vec![
             Address::from(net::SocketAddr::from(([41, 12, 98, 112], 8776))),
             Address::from_str("seed.cloudhead.io:8776").unwrap(),
         ],
         ..Config::test(Alias::new("alice"))
     });
     let working = tempfile::tempdir().unwrap();
     let alice = alice.spawn();