Support keyword arguments in @formula function calls

[sdwfrost]

Summary

Allow keyword arguments in @formula function calls, enabling syntax like:

@formula(y ~ s(x; k=10, bs=:cr))
@formula(y ~ foo(x, a=1, b=2))

Currently, both forms crash in parse! because :kw and :parameters AST nodes
hit check_call() which requires head == :call. This PR adds handling for these
nodes so they pass through as quoted literals in FunctionTerm.args.

Motivation

Downstream packages that extend @formula with custom function terms (e.g., GAM
smooth specifications like s(x; k=10, bs=:cr)) need keyword arguments to configure
those terms. Without this change, users must use a separate macro (@gam_formula) or
encode configuration as positional arguments (cr(x, 10)), which is less readable
and less discoverable.

This is a common need — R's formula interface supports s(x, k=10, bs="cr") in mgcv,
and Julia's native call syntax already supports kwargs. The parser just needs to not
crash on them.

Changes

src/formula.jl

• Add early-return parse! handling for :kw and :parameters Expr nodes — quotes
  them so they survive as literals in FunctionTerm.args
• Add parse!(::QuoteNode, ...) method for quoted symbols (e.g., :cr)

src/terms.jl

• Add kwarg_exprs(ft::FunctionTerm) — extract keyword argument expressions from
  FunctionTerm.exorig for downstream use
• Add has_kwargs(ft::FunctionTerm) — convenience predicate

src/StatsModels.jl

• Export kwarg_exprs, has_kwargs

test/formula.jl

• 16 new tests covering semicolon kwargs, comma kwargs, mixed positional+kwargs,
  symbol values, numeric values, no-kwargs backward compatibility

Design

The approach is deliberately minimal and backward-compatible:

1. No struct changes — FunctionTerm already stores exorig (the original Expr),
   which naturally contains kwargs. We just need parse! to not crash before
   FunctionTerm is constructed.

2. Kwargs are opaque to StatsModels — they pass through as quoted expressions.
   StatsModels does not interpret them. Downstream packages inspect them in their
   apply_schema implementations via kwarg_exprs(ft).

3. Full backward compatibility — existing formulas produce identical results.
   All 965 existing tests pass unchanged.

Test Results

• 981 tests pass (965 existing + 16 new)
• 9 broken (all pre-existing)
• 0 failures, 0 errors

Example Usage (downstream package)

using StatsModels

# Parse formula with kwargs
f = @formula(y ~ s(x; k=10, bs=:cr))

# Extract kwargs in apply_schema
function StatsModels.apply_schema(ft::FunctionTerm{typeof(s)}, schema, ...)
    kws = kwarg_exprs(ft)
    # kws = [:(k = 10), :(bs = :cr)]
    k = get_kwarg(kws, :k, 10)      # extract specific kwarg
    bs = get_kwarg(kws, :bs, :tp)
    # ... build smooth specification
end