Merge pull request duckdb/duckdb#13062 from Mytherin/macrooverloads

This PR implements (optional) types for macro parameters.

#13062 Implemented macro overloads:
```sql
CREATE MACRO m
	(a) AS a,
	(a, b) AS a + b,
	(a, b, c) AS a + b + c;
SELECT m(40, 2);
-- 42
```
Allowing different behavior based on the supplied arguments.

More recently, #18684 improved how
arguments can be supplied to macro's:
```sql
CREATE MACRO m(a, b := '2') AS a || b;
SELECT m(a := '4');
-- 42
```
Allowing parameters without a default to be used by name, and parameters
with a default to be used by position.

This PR implements typed macro parameters, allowing macro's with the
same number of parameters to be overloaded by type:
```sql
CREATE OR REPLACE MACRO m
    (a TINYINT) AS a + 1,
    (a SMALLINT) AS a + 2,
    (a INTEGER) AS a + 3,
    (a BIGINT) AS a + 4,
    (a HUGEINT) AS a + 5,
    (a) AS a + 10;
 SELECT m(39::INTEGER) i;
-- 42
```
The macro overload is selected similar to our regular functions, and
typed parameters can be mixed with untyped parameters:
```sql
CREATE MACRO m
    (a VARCHAR) AS a || '2',
    (a INTEGER, b) AS a + b,
    (a, b INTEGER) AS a - b;
SELECT m(4);
-- Macro m() does not support the supplied arguments. You might need to add explicit type casts.
SELECT m(4::VARCHAR);
-- 42
SELECT m(40, 2);
-- Macro m() has multiple overloads that match the supplied arguments.
SELECT m(40, 2::TINYINT);
-- 42
SELECT m(44::TINYINT, 2);
-- 42
```
Explicit types can also be supplied for parameters with default values:
```sql
CREATE MACRO m(a VARCHAR := 42) AS a;
-- Default value '42' for parameter 'a' cannot be implicitly cast to 'VARCHAR'. Please add an explicit type cast.
CREATE MACRO m(a VARCHAR := '42') AS a;
SELECT m();
-- 42
SELECT m(42);
-- Macro m() does not support the supplied arguments. You might need to add explicit type casts.
```

This is useful for when different types require different behaviour, or
when you don't want to accidentally supply an argument with a certain
type to a function (which happens to me all the time in Python!).

I've also significantly improved the binding process of macro's in
general, written more descriptive error messages, and unified a lot of
the scalar macro binding code with table macro binding code. All of the
tricks above should also work for table macro's.

Note that this is only supported with in-memory databases, temporary
macro's, or with v1.4.0 storage or later:
```sh
# in-memory DB
duckdb -c "CREATE MACRO m(a INTEGER) AS a;"
# works

# disk DB
duckdb my.duckdb -c "CREATE MACRO m(a INTEGER) AS a;"
# Typed macro parameters are only supported for storage versions v1.4.0 and higher.

# temporary macro for disk DB
duckdb my.duckdb -c "CREATE TEMPORARY MACRO m(a INTEGER) AS a;"
# works

# explicit v1.4.0 storage
duckdb -c "ATTACH 'my.duckdb' AS my (STORAGE_VERSION 'v1.4.0'); USE my; CREATE MACRO m(a INTEGER) AS a;"
# works
```