cli: Deprecation and Obsoletion Warnings — heartwood

The following deprecations/obsoletions were discussed in Zulip or are already in master. The aim here is to unify and fix.

Deprecated in favor of rad node status --only nid.

This command was deprecated before, but in a way that broke its output on standard output. It now prints to standard error.

Deprecated in favor of git diff.

Obsolete. See issue/9a047d07ee00d0733adedb4a279fbd158342a586.

 ## Deprecations
 - The option `rad self --nid` was deprecated in favor of `rad status --only nid`
 - `rad diff` was deprecated in favor of using `git diff`
 - `rad patch review --patch` and `rad patch review --delete` are made obsolete.
   This functionality never worked as intended, and may be removed before the
   next major release.
 ## New Features
 - `rad clone` now supports the flag `--bare` which works analoguously to

 - `rad init --setup-signing` now works on bare repositories.
 - `git-remote-rad` now correctly reports the default branch to Git by listing
   the symbolic reference `HEAD`.
 - `rad status` learned a new option `--only nid` for printing the Node ID.
 ## Fixed Bugs

 ``` (stderr)
 $ rad diff
 ! Deprecated: The command/option `rad diff` is deprecated and will be removed. Please use `git diff` instead.
 ```
 Exploring `rad diff`.
 ``` ./main.c

 ```
 $ rad self --nid
 ! Warning: The option `--nid` is deprecated, please use `rad node status` instead.
 z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi
 ```
 ``` (stderr)
 $ rad self --nid
 ! Deprecated: The command/option `rad self --nid` is deprecated and will be removed. Please use `rad node status --only nid` instead.
 ```
 ```
 $ rad self --ssh-key
 ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIHahWSBEpuT1ESZbynOmBNkLBSnR32Ar4woZqSV2YNH1

 }
 pub fn run(options: Options, _ctx: impl term::Context) -> anyhow::Result<()> {
     crate::warning::deprecated("rad diff", "git diff");
     let repo = rad::repo()?;
     let oids = options
         .commits

 use std::ffi::OsString;
 use std::path::PathBuf;
 use std::str::FromStr;
 use std::time;
 use std::{process, time};
 use anyhow::anyhow;

     --timeout <secs>     How long to wait to receive an event before giving up
     --count, -n <count>  Exit after <count> events
 Status options
     --only nid           If node is running, only print the Node ID and exit,
                          otherwise exit with a non-zero exit status.
 General options
     --help               Print help

     Logs {
         lines: usize,
     },
     Status,
     Status {
         only_nid: bool,
     },
     Inventory {
         nid: Option<NodeId>,
     },

         let mut addresses = false;
         let mut path = None;
         let mut verbose = false;
         let mut only_nid = false;
         while let Some(arg) = parser.next()? {
             match arg {

                     let val = parser.value()?;
                     nid = term::args::nid(&val).ok();
                 }
                 Long("only") if matches!(op, Some(OperationName::Status)) => {
                     if &parser.value()? == "nid" {
                         only_nid = true;
                     } else {
                         anyhow::bail!("unknown argument to --only");
                     }
                 }
                 Long("json") if matches!(op, Some(OperationName::Routing)) => json = true,
                 Long("timeout")
                     if op == Some(OperationName::Events) || op == Some(OperationName::Connect) =>

                 path: path.unwrap_or(PathBuf::from("radicle-node")),
             },
             OperationName::Inventory => Operation::Inventory { nid },
             OperationName::Status => Operation::Status,
             OperationName::Status => Operation::Status { only_nid },
             OperationName::Debug => Operation::Debug,
             OperationName::Sessions => Operation::Sessions,
             OperationName::Stop => Operation::Stop,

                 println!("{}", term::format::tertiary(rid));
             }
         }
         Operation::Status => {
         Operation::Status { only_nid: false } => {
             control::status(&node, &profile)?;
         }
         Operation::Status { only_nid: true } => {
             if node.is_running() {
                 term::print(term::format::node_id_human(&node.nid()?));
             } else {
                 process::exit(2);
             }
         }
         Operation::Stop => {
             control::stop(node, &profile);
         }

             unified,
             hunk,
         } if by_hunk => {
             crate::warning::obsolete("rad patch review --patch");
             let mut opts = git::raw::DiffOptions::new();
             opts.patience(true)
                 .minimal(true)

             }
         }
         Operation::Delete => {
             crate::warning::obsolete("rad patch review --delete");
             let name = git::refs::storage::draft::review(profile.id(), &patch_id);
             match repository.backend.find_reference(&name) {

             term::print(profile.config.alias());
         }
         Show::NodeId => {
             term::warning(
                 "The option `--nid` is deprecated, please use `rad node status` instead.",
             );
             crate::warning::deprecated("rad self --nid", "rad node status --only nid");
             term::print(
                 Node::new(profile.socket())
                     .nid()

     ));
     warnings
 }
 /// Prints a deprecation warning to standard error.
 pub(crate) fn deprecated(old: impl std::fmt::Display, new: impl std::fmt::Display) {
     eprintln!(
         "{} {} The command/option `{old}` is deprecated and will be removed. Please use `{new}` instead.",
         radicle_term::PREFIX_WARNING,
         radicle_term::Paint::yellow("Deprecated:").bold(),
     );
 }
 /// Prints an obsoletion warning to standard error.
 pub(crate) fn obsolete(command: impl std::fmt::Display) {
     eprintln!(
         "{} {} The command `{command}` is obsolete and will be removed. Please stop using it.",
         radicle_term::PREFIX_WARNING,
         radicle_term::Paint::yellow("Obsolete:").bold(),
     );
 }