"Lisp macros are a key feature that no other language has" is a vague and subjective statement, but there's definitely a real point behind it. If you really want to know how macros are such a key feature, you should read "On the Expressive Power of Programming Languages", which is a paper that Matthias Felleisen wrote, where he defines the concept of "expressive power" more formally.
As for Graham's assertion that no other language has something equivalent, there are two sides for that. On one hand, as time goes by it is less and less true. There are several modern languages that have started to play with reflective capabilities, and specifically with macros. As a sidenote, macros are very different from some
eval function even though it looks like you can do similar things with them. Also, some of these reflective facilities come in the form of parsers -- but if you read the above paper you'll see that one of the major aspects of macros is that they are local transformation rules, which means that you can extend a language rather than define a new language by translation.
The second point is that "Lisp macros" is itself a concept that is not too well defined. For example, many Lisps have symbolic macros, while Scheme macros look very different (and I won't go into opinions about the differences). In addition, Lisps traditionally have "reader macros" which are somewhat like macros in that they can extend the existing language, but they operate at the level of reading the source code, which means that you can extend the actual syntax of the language. Again, an important point here is extending the existing syntax rather than writing a whole new parser (which is possible as with all languages, but requires much more effort).
Finally, this is still an area where development is going on. An obvious example would be Racket (a dialect of Lisp/Scheme), which has a very powerful macro system & a reader macro facility, but it goes beyond traditional lisps by making it work with a module system, well defined stages for starting from text and getting to executable code, investigating the concept of macros as a kind of "compiler plugins" and much more. The result is a language which makes it very easy to define and use new dialects, essentially making it a greenhouse for growing languages.