… argument

Functions such as this one

```res
let foo1 = (~x=3, ~y) => x+y
```

 normally require a final unit unlabeled argument to indicate that the optional argument `x` is not passed.

In this example, writing

```res
let r1 = foo1(~y=11)
```

makes `r1` a function that is still expecting the `x` argument.

Requiring a final unit argument, and passing it as `foo1(~y=11, ())` is the only way to omit `x` in  practice.

With uncurried functions, there's the opportunity to treat `foo1(~y=11)` in a special way, meaning that argument `x` is omitted.

TODO:
- Figure out what to do with the warning ""This optional parameter in final position will, in practice, not be optional"
- Figure out the case of all optional arguments. There's no way to pass zero arguments. One could interpret `foo()`, which actually passes `()` as single unlabelled argument, in a special way when `foo` does not accept unlabelled arguments, and use it to mean zero arguments passed.

…type checker.

In reality this disables also the check for the body, but this check is on the way out so this should be reasonable in practice without over-complicating the error logic.

When all the processed arguments to the function are ignored (hence optional), and no arguments are ignored (so no mandatory labelled), it means the uncurried function only has optional arguments.

- If the uncurried type of the function had an unlabelled arg, then it would be caught by the unit application, so it would be a non-ignored argument. But this is not possible as all the argiments are ignored.
- If it had a labelled mandatory argument, then either it would be non-ignored, or omitted, but both cases are excluded.
- It follows that the type only has optional arguments, and that the unit argument was the only argument supplied.

The new mechanism does not kick in when some legit argument is passed alongside the unit. And noes not interfere with cases where the function expects a legitimate unit argument.