Assuming you don't change the syntax of dotted lists, a problem is that you wouldn't be able to use an expression for "xs".
The dot notation creates a cons for you, and a cons creates a regular list if its second argument is nil or another cons (which itself is a regular list).
'(a . (b))
(cons 'a '(b))
which in turn is like
which you can see for yourself:
arc> '(a . (b))
So an expression like
(bar x . (foo))
that we'd want to work like
(apply bar x (foo))
is parsed by the reader like this:
arc> '(bar x . (foo))
(bar x foo)
and by the time the compiler sees the expression there's nothing there to tell it that a dot was used.
Of course, if you change the reader so that a dot doesn't produce a dotted list but instead creates a token for the compiler to see, then you can do whatever you want... though you'd also need to extend the compiler to handle the dot notation in the other places which is currently handled by the reader.
I think the number of times I use 'apply with a variable in the final position is enough for the syntax to be relevant to me... but then I'd be likely to refactor (a b c . d) into (apply a b c (something-else)) and vice versa all the time, which would be a bit of a pain. Then again, it's balanced against the cost of refactoring (a b c) into (a b c . d) and vice versa....
by the time the compiler sees the expression there's nothing there to tell it that a dot was used.
In Racket's syntax there is a way, I think. It makes syntax more complicated than just its conses, though. You'd have to use an Arc variant of syntax-quasiquote (or just syntax-quasiquote) to construct it in macros.
Meanwhile, the (cdr `(foo . ,<scheme-expr>)) quirk would become more of a bug than it already is. But then I assume whatever Arc hack implements this syntax would also have '$ built in, so there's probably no point to keeping the quirk around.