The best thing about Lisp IMO is the way it exposes the underlying mechanisms. This is most evident in its syntax and macro system, which makes you really think about scope and binding order and the full implications/uses/interactions between multiple lexical environments, but generic functions is another good example. Prior to Lisp I'd tinkered in C++ and Java and I'd always thought of methods as these vaguely functionlike things that were nonetheless quite different and inseparably tied to certain common OO paradigms. CLOS made me realize that a method is just a function that:
1. Is designed to always accept one object as an argument (silly and arbitrary limitation.)
2. Examines the type of its arguments to determine which version of the function to use. This is usually determined via a very rigid inheritence scheme, whereas CLOS treats everything as an object and allows you to specify completely arbitrary patterns to match, with the default behavior being to use the most "specific" (to the arguments' types) method available. Also, as I said before, you can chain together parent methods in arbitrary ways instead of having to choose to either overwrite or keep the parent method.
Regarding your question about the lack of Lisp dominance, the answer is both simple and sad. Programming language popularity is driven by a combination of novel coolness and the marketing powers that be, not merit. Also, "good enough" syndrome prevents many programming languages (and applications for that matter) from absorbing very minor, taken-for-granted features that newcomers will expect, so the learning curve becomes a lot steeper than it should be. In Lisp this takes the most obvious form of not giving noobs an easier sub-language that doesn't require constant use of parens. Lisp veterans recognize that explicit scoping is highly desirable in most cases and have trained themselves to read and type it easily, but this isn't of much consolation to a newcomer, especially if they are attempting to use an editor without proper paren matching or auto intendation.
You're probably right in Clojure being the future of Lisp, but this is a perfect (and very depressing) example of what I just explained. Clojure is inferior in every way to Scheme or Common Lisp except it runs on JVM and it has a few native concurrency features. The latter sounds nice but who the hell cares about native concurrency if your language is several orders of magnitude slower? Common Lisp has concurrency libraries. It is also a true compiled language and with proper declarations can made to run at around 50% the speed of well written C. The problem is, Lisp wasn't always so fast. It took decades to reach that point during a period when computers were really, really slow. (People actually needed hardware acceleration to run it at acceptable speeds: see "Lisp Machine") By the time it became fast enough, the cool kids had moved on, so the Lisp crowd had to sit back and watch the new generation painfully re-discover all of those amazing features like garbage collection, weak/optional strong typing, closures, etc. And they're still nowhere near where Lisp was a quarter century ago.
If you want to hear some more CL cheerleading and get a small taste of some of its powers that modern languages still can't touch, check out Paul Graham. His book On Lisp is available online now:
http://www.paulgraham.com/onlisptext.html . If you find that interesting, Let Over Lambda is a very smug little book almost guaranteed to blow your mind:
http://letoverlambda.com/index.cl/toc . Some of Hoyte's ideas seem demented, but others (especially regarding the role of syntax, referential transparency being overrated, and the right way to use lexical environments) are quite profound.