I believe the short answer to your questions is that macros and other special forms could be first-class objects--there is no semantic reason to forbid it--but that compiler writers would scream and run away in horror.
(To begin with, any _expression_ of the form ((car x) y ...) could be a macro call, and hence the arguments "y ..." cannot be evaluated until it is determined--at run time--that (car x) is in fact a function. Furthermore, consider this case:
(let ((x (cons y z)))
((car h) (cdr x))
(+ 4 (car x)))
(car h) could conceivably be a macro that would extract the "x" from the "(cdr x)" _expression_ and produce "(set-car! x 8)" or something like that. Therefore, it would be unsound for the compiler to simply replace "(car x)" with "y". --Calling functions from data structures, as in "((car fs) a b)", seems a rare thing to do, but now we must realize that global variables can usually be modified too, and if ((car mac-list) x) always gets the current car of the mac-list (as opposed to extracting the car once and assuming it'll always remain the same), it would be terribly inconsistent if (f x) did not get the current value of f and, if it happened to be a new macro, to expand some new code and run it. Therefore, the compiler must assume that even "(f (cdr x))" could actually modify the car of x, if f might be redefined in between when this code is compiled and when it is run. I expect real compiler writers could produce more common and compelling examples of important optimizations that become impermissible (or incredibly difficult) in the presence of first-class macros (loop invariants come to mind).
I believe it is nevertheless possible--using partial evaluation, rules about when threads learn of updated global variables, and a system of invalidating and recompiling functions--to have efficient compiled code and first-class macros, but I don't think such a system exists right now.)
You might find some Scheme or Lisp interpreters that provide macros and special forms as first-class objects--in fact, I have an Arc interpreter that does just this--but don't expect to find it in compilers, or language standards, any time soon.