(defun foo (&key x y) ...)

could be compiled as:

 (defun foo (&rest args) ;hopefully rarely called, so ok to be slow
   (destructuring-bind (&key x y) args
     (internal-foo x y)))
 (defun internal-foo (x y) ...)

with additional bookkeeping so that

 This...                    Compiles to...
 (foo :x (f))               (internal-foo!x-* (f))
 (foo :x (f) :x (g))        (internal-foo!x-x (f) (g))
 (foo :x (f) :y (g))        (internal-foo!x-y (f) (g))
 (foo :y (g) :x (f))        (internal-foo!y-x (g) (f))

where you then made sure the appropriate positional stubs were
present at load time, and where all each stub did was shuffle the
args and call the central entry point.  You could punt to the
general purpose entry point if you were exceeding a stub limit or
if apply had been used.

It would be nice if there was a simple way to request this stuff of
the compiler.  I've ended up writing stuff like this for special
purpose use from time to time, but I lament that most compilers aren't
committed to doing it for me.  Yes, it involves a proliferation of
symbols, but for heavily used interfaces, it's what you need.

It's pretty similar to the way "number calling" used to work (for
functions in Maclisp that were declared to take or return fixnums or
flonums).  The public entry point did not assume special stuff, but
people who had special knowledge of what was going on knew the secret
way to enter the function bypassing the general prolog.

(Really far afield: The trick was in Maclisp that the general purpose
function entry point had a "pushj" to another function as the first
instruction that would unpack the gneral purpose args into number args
and add an additional return frame to the stack so that on the way
out, the number-called internal function would have its args re-packed
into a general purpose call form that the caller expected.  so
number-called functions always blindly entered at the second
instruction, bypassing both the unpacking and the prep for the later
re-packing.  This sometimes led to "fun" cases where people
number-declared functions that weren't number functions and the wrong
thing happened, so you have to be careful.  Once I heard of it
happening deliberately: I remember some bug report from George
Carrette with the subject line "crowbar in head" where he'd finally
tracked down a case of brain damage where someone trying to get past
an error checking instruction ("skipe *rset", in pdp10-ese, if I
recall) by declaring the function a number function.  But the function
code changed and that was no longer the first instruction.  The joys
of cheating.  Life was interesting back then.)