Combinatoric example

```no_run
const BINARY_USAGE: &[(&str, Style)] = &[
    ("--binary", Style::Literal),
    ("=", Style::Text),
    ("BINARY", Style::Metavar),
];

#[derive(Debug, Clone, Bpaf)]
#[bpaf(options)]
pub struct Options {
    /// Binary to run
    #[bpaf(short, long, argument("BIN"), custom_usage(BINARY_USAGE))]
    binary: Option<String>,

    /// Package to check
    #[bpaf(short, long, argument("PACKAGE"))]
    package: Option<String>,
}

fn main() {
    println!("{:?}", options().run())
}
```


Derive example

```no_run
#[derive(Debug, Clone)]
pub struct Options {
    binary: Option<String>,
    package: Option<String>,
}

pub fn options() -> OptionParser<Options> {
    let binary = short('b')
        .long("binary")
        .help("Binary to run")
        .argument("BIN")
        .optional()
        .custom_usage(&[
            ("--binary", Style::Literal),
            ("=", Style::Text),
            ("BINARY", Style::Metavar),
        ]);

    let package = short('p')
        .long("package")
        .help("Package to check")
        .argument("PACKAGE")
        .optional();

    construct!(Options { binary, package }).to_options()
}

fn main() {
    println!("{:?}", options().run())
}
```


Output

`custom_usage` changes how parser shows up in the "Usage" section of generated `--help`, note
lack of `[]`, long name instead of a short one and different metavariable value

$ app --help

Usage: app --binary=BINARY [-p=PACKAGE]

Available options:

-b, --binary=BIN

Binary to run

-p, --package=PACKAGE

Package to check

-h, --help

Prints help information

Parsing behavior stays unchanged

$ app --binary cargo-asm --package cargo-show-asm
Options { binary: Some("cargo-asm"), package: Some("cargo-show-asm") }

