(Yes, several of those are implemented as reader macros. I don't see how that would make them any easier to learn than the same feature implemented as "syntax".)
That's not a knock against it. I think Clojure is the best general-purpose language today, but we've come a long way in the past few decades. Lisp is no longer a language whose implementation fits on a blackboard (and everyone extends it in their own way). We've discovered a bunch of common functionality that almost all programs need, and pushed it up into the stdlib and language.
That's not true. Lisp has lots of syntax - actually more than most programming language, because the syntax is arbitrarily extensible via macros.
The idea of (operator param param ...) is only valid for function calls, but even then the syntax is slightly more complex, since several Lisps have keyword arguments.
But besides (operator param param ...) Lisp also has:
((lambda (arg ...) . body) param ...)
(special-operator ...)
and
(macro-operator ...)
Each special operator comes with syntax. Example is LET.
LET is not
(LET param param)
but
(let (arg ...) declarations . body)
where arg is arg | (arg value)
declaration the is something complex like
(declare (type (integer 0 3) arg))
for a type declaration for the variable arg, which is an integer in the range of 0 to 3.
Systems don't always/often win because they're the best or most liked.
As with political views, most people prefer the ones they first learned. Only later in life, perhaps after becoming dissatisfied with what they know, they may risk trying something very different.
My CS education was the typical Pascal/C/C++, so it wasn't decades later until I actually learned a Lispy language. But I had read enough to know that a lot of very intelligent people had loved Lisp; surely there was something to that.
Likewise, the people who grew up on Lisp probably only grudgingly moved _down_ the ladder to use some of the more popular languages ;).