Move stable function evaluation into `invoke()` instead of `simplify()`

[adriangb]

As discussed in #19426 currently evaluation of stable functions is handled in ScalarUDFImpl::simplify().
It would be nicer if it could be handled in ScalarUDFImpl::invoke_with_args:

1. If no simplifier is run the function can have runtime behavior, e.g. returning the fixed execution time.
2. If a simplifier is run the simplifier can call invoke_with_args to hit the same code path.

This seems to require refactoring PhysicalExpr::evaluate(RecordBatch) into PhysicalExpr::evaluate_with_args(EvaluateArgs) where EvaluateArgs is symmetrical to ScalarFunctionArgs

[adriangb]

It occurred to me that one option is to evaluate these functions by caching the results during planning / optimization, inside of the same optimizer rule that handles this right now.

Essentially we traverse the logical plan looking for all expressions (there is infrastructure to make this easy) and for every function that is:

1. Stable
2. Has no inputs

We store a HashMap<&str, Expr::Literal> (or some other way to reference the function aside from the name). The first time we encounter a function we evaluate it (we'll have to implement NowFunc::invoke_with_args to call Utc::now()) and get out the literal value. Subsequent encounters with that function it would be replaced with the literal.

So essentially DataFusion handles the "immutability" of this function for users, users just have to implement the function as normal.

If there are stable functions with arguments (currently none exist that I know of) we would error during the optimizer pass.