remove clap feature from LogLevel

[mattsse]

Describe the feature

enabling features for crates deep in the stack is very inconvenient

reth/crates/storage/errors/src/db.rs

Line 103 in fe823cb

#[cfg_attr(feature = "clap", derive(clap::ValueEnum))]

This feature is only used here

reth/crates/node-core/src/args/database.rs

Lines 11 to 13 in fe823cb

	/// Database logging level. Levels higher than "notice" require a debug build.
	#[arg(long = "db.log-level", value_enum)]
	pub log_level: Option<LogLevel>,

TODO

• remove clap support and instead implement a value parser that manually does this

this is the generated code

impl clap::ValueEnum for LogLevel {
        fn value_variants<'a>() -> &'a [Self] {
            &[
                Self::Fatal,
                Self::Error,
                Self::Warn,
                Self::Notice,
                Self::Verbose,
                Self::Debug,
                Self::Trace,
                Self::Extra,
            ]
        }
        fn to_possible_value<'a>(
            &self,
        ) -> ::std::option::Option<clap::builder::PossibleValue> {
            match self {
                Self::Fatal => {
                    Some({
                        clap::builder::PossibleValue::new("fatal")
                            .help(
                                "Enables logging for critical conditions, i.e. assertion failures",
                            )
                    })
                }
                Self::Error => {
                    Some({
                        clap::builder::PossibleValue::new("error")
                            .help("Enables logging for error conditions")
                    })
                }
                Self::Warn => {
                    Some({
                        clap::builder::PossibleValue::new("warn")
                            .help("Enables logging for warning conditions")
                    })
                }
                Self::Notice => {
                    Some({
                        clap::builder::PossibleValue::new("notice")
                            .help("Enables logging for normal but significant condition")
                    })
                }
                Self::Verbose => {
                    Some({
                        clap::builder::PossibleValue::new("verbose")
                            .help("Enables logging for verbose informational")
                    })
                }
                Self::Debug => {
                    Some({
                        clap::builder::PossibleValue::new("debug")
                            .help("Enables logging for debug-level messages")
                    })
                }
                Self::Trace => {
                    Some({
                        clap::builder::PossibleValue::new("trace")
                            .help("Enables logging for trace debug-level messages")
                    })
                }
                Self::Extra => {
                    Some({
                        clap::builder::PossibleValue::new("extra")
                            .help("Enables logging for extra debug-level messages")
                    })
                }
                _ => None,
            }
        }
    }

this can also be solved by copying the value_variants and add a fn help_message which the value parser then uses

Additional context

No response

[JackG-eth]

Happy to take