While I do like the terseness of this idea, unfortunately it will not be possible without changes to the syntax, which makes it harder to justify, especially since ... outside of a function overload would be nonsensical but it would still have to be valid syntax otherwise. So I don’t think this makes sense unless overloads become their own AST node with their own grammar rules.
Maybe we can come up with a way that’s syntactically valid, non-ambiguous and still relatively terse.
Maybe something like *_: auto and **_: auto meaning the elided arguments would be determined by the following overloads. The issue with that approach however is that we can’t easily and non-ambiguously elide positional arguments, maybe we’d need something like _: ellide(n) to skip n positional arguments.
There’s an existing thread where I also shared some of my thoughts about how to at least reduce the number of overloads you have to write due to the complications introduced through arguments that can either be positional or keyword: Some improvements to function overloads