Adding hugging in `fn1(fn2())` style calls

[DavisVaughan]

abort(glue::glue(
  "Length implied by `dim`, {n_elements}, must match the length of `x`, {n_x}."
))

Formatted as this right now

abort(
  glue::glue(
    "Length implied by `dim`, {n_elements}, must match the length of `x`, {n_x}."
  )
)

But its quite nice with the hug

(Something about enabling this when the only unnamed argument to a function call is another function call, but should respect that leading line break if user wants to expand!)

(quite common across dplyr and elmer)

[DavisVaughan]

Waiting until we get some other PRs merged before really working on this, but it is kind of like this

fn is_hugging_call(items: &RArgumentList) -> SyntaxResult<bool> {
    if items.len() != 1 {
        return Ok(false);
    }

    // Safety: Valid because of the length check above
    let item = items.first().unwrap()?;

    let item = match item {
        AnyRArgument::RUnnamedArgument(item) => item.value()?,
        AnyRArgument::RNamedArgument(item) => match item.value() {
            Some(item) => item,
            None => return Ok(false),
        },
        AnyRArgument::RBogusArgument(_)
        | AnyRArgument::RDotsArgument(_)
        | AnyRArgument::RHoleArgument(_) => return Ok(false),
    };

    // TODO: Bail on hugging if `item` has any comments.
    // Make sure to check `name` and `value` components of named arguments,
    // and the argument node as a whole.
    //
    // abort(# comment
    // glue(
    //   "Length imasdfasdfasfsadfsadfasfsafasfadfafsdfplied by `dim`, {asdfasdfn_s"
    // ))

    Ok(matches!(
        item,
        AnyRExpression::RCall(_) | AnyRExpression::RSubset(_) | AnyRExpression::RSubset2(_)
    ))
}

struct FormatHuggingCall<'a> {
    l_token: &'a dyn Format<RFormatContext>,
    argument: &'a FormatCallArgument,
    r_token: &'a dyn Format<RFormatContext>,
}

impl<'a> Format<RFormatContext> for FormatHuggingCall<'a> {
    fn fmt(&self, f: &mut Formatter<RFormatContext>) -> FormatResult<()> {
        // For simplicity, we effectively treat `outer(inner(` below as one token.
        // This means that if `outer(inner(` is very long, it can exceed the line
        // limit without breaking. We prefer keeping it together over breaking in
        // this scenario (plus it seems quite hard to group in a way that would
        // support hugging unless `outer(inner(` would exceed the line limit).
        //
        //  outer(inner(arg1, arg2))
        //  ------------          --
        //      |- One token      |- One token
        write!(
            f,
            [group(&format_args![
                self.l_token,
                self.argument, self.r_token
            ])]
        )
    }
}

And used like

        // Special case where our call has exactly 1 argument, which is another call.
        // In that case, we prefer "hugging" the inner call
        if is_hugging_call(&self.items)? {
            let argument = arguments.first().unwrap();

            return write!(
                f,
                [FormatHuggingCall {
                    l_token: &self.l_token.format(),
                    argument,
                    r_token: &self.r_token.format(),
                }]
            );
        }