I'm going to start where a lot of people don't usually start. The actual people who maintain X11. They hate the code base, they just simply don't want to deal with the tangled mess that it is. Seriously go look at a dependency graph of just the xserver or a slightly higher level view of the state of things. Point, no one wants to maintain this mess. Anyone feeling frisky in doing so is strongly encouraged to do so, but the majority of developers who have worked on this in the heyday have long since left the building. The sheer pool size of people working on X is low and fresh blood in the development pool is best described as anemic. Fewer developers working on one project and more on another project pretty much seals the deal on the direction. Arguments of X being better falls on non-existent ears. You want to talk to an X developer? Head over to Wayland, that's where you'll find a lot of them.
Next in line is that X is ineffective at one of the things that it's suppose to do, draw stuff on your screen. (Not even going to touch multi-monitor, sleep, touch input, etc all which have had extensive hacking to get it working and thus resulting in patches of code with serious bus factor one issues.) X11 lacks pretty much everything we take for granted in a modern GUI. Want anti-alias text? Well X11 doesn't do that. Want the concept of an alpha-channel? Not present in X11. Quite literally, X11 does nothing in the way of anything that say KDE, GNOME, Unity, Cinnamon, or whoever wants. Instead, your chosen toolkit is using a library that builds in memory the bits that need to be drawn and if your xserver supports RENDER, your toolkit just gives a stream of bits over to X11 via that method, and X just forwards it on to either the card or to a compositor, which by the way X11 doesn't have a concept of, hence the reason you need one external to the xserver. At some point someone said, if every toolkit is just building bits by themselves and then having X forward it on, why not just cut out the middle man? Why have this extra layer that we keep having to build ad-hoc extensions for? (RENDER, XDamage, RANDR, XFixes **yes literally an extension to fix stuff but mostlly to turn a lot of old X11 stuff off.) All of these wonderful extensions are in reality short circuiting old cruft in a code-ugly fashion. Add in new complexities being added to video cards, functionality that's difficult to eventually get working, and yeah everyone is ready to put the old girl out to pasture. X11's lack of so many things is a roadblock to tapping your card's fully ability, which is why most of the time we're happily ignorant of all of the by-passing of huge parts of the core of an xserver, with the prolific set of extensions that come automatically built into your distro. (which is why a lot of folks never notice and just think that this is the way X was built, but nothing further from the truth could be said. Try building an xserver from source.)
Now let me move on to your points
Network transparency. X11 has it. Wayland doesn't.
If you are using X11 over ssh, you aren't using X11's network transparency. What you are doing is streaming pixels across ssh, but you aren't using anything remotely looking like core X11 protocol. On the remote side, Cario, Qt, Mutter, or someone is drawing pixels and then that gets wrapped into a generic X11 package and sent to you to open up and then have your computer decide what to do with the newly received pixels. There's no commands like "Window A is currently at location x,y. It has a button at rx, ry relative to the top-left corner of the parent widget, blah blah blah." Nope, it's just "here's pixel one, here's pixel two, here's pixel three..." There's no distinction in X between a button in an application running on a remote server and a picture of a button, that's all handled higher up in the stack, and it's been this way for pretty much all of this side of Reagan's presidency.
So that said, what stops Wayland from blowing pixels over a wire? Literally, nothing, aside from the fact that zero of the developers in Wayland see a point to it. Also, there's not that many X developers that see a point to it either. Streaming pixels over a pipe is silly and there's literally a billion different ways of doing that, that are so much better. Also, there's been a few patches to X extensions (fixes to extensions that were fixes) to make this streaming a bit better over the years, but like everything X, it has turned into a tangled mess of code that brings blood to the eyes of those who look upon it. In light of all the other things out there that do this better, there's just more places in X and Wayland to spend developer time on than in this specific area. However, anyone feeling frisky enough to tackle the X code or start building one in Wayland, by all means go for it. Saying X11 has network transparency, which it does, does not equal to you or anyone else actually sending *real mcdeal* X11 commands over a pipe, you're just sending pixels and there's nothing technically preventing Wayland from doing that too.
On top of that they're doing the #1 thing you're not supposed to do in development: completely rewriting a working system.
This is the way we've done it and by golly this is the way we're always going to do it. /s
But seriously, you'd have to use a really loose definition of "working" to apply that to today's X11 stack that most people are using. If you're looking at your Linux desktop right now and the graphics are smooth and buttery, that's not because of some awesome thing in X, it's because you have great drivers that know how to effectively by-pass X and get right to your card. By all means, let me know how well LibreOffice works using nothing but X11 primitives in Xlib.
X11's main flaw is that it's supposed to be inefficient.
It is, just so we're clear on this point. That you've not noticed it isn't because of anything X actually does. The underlying tool kits are mostly by-passing things left and right. Here's a quick overview of DRI Now most windowing systems are using OpenGL to some level to draw. You can see that just goes right to the DRI driver which then sends it on lower in the stack, no X required. Other parts of your desktop are using GLX to render indirectly, which X11 does see the package coming in, but then reroutes it to the DRI driver via AIGLX. Actual old ass X11 applications go through the entire stack before eventually making it to the lower layers, chances are, you aren't using any of them. However, I don't know what programs you're using, you could very well be breaking out twm on the daily. But the majority of Linux users are using toolkits and desktops that have long since circumvented X11's core protocol.
I'm not happy about this.
No one is happy about it. Let me clarify, no one who actually worked on X11's code is absolutely happy about this direction. That's quite a few decades worth of code that has slowly become an unusable mess for a variety of reasons that range from forward thinking that just never panned out to outright WTF were they thinking? However, the Wayland developers aren't idiots. They realize that X is going to be around for a very, very, very long time. I swear, I hear people tossing shade at Wayland like they've banned anyone from ever using X ever again. Just like IBM AS400, IPv4, and Java, we're stuck with X for the foreseeable future and thinking that the Wayland developers don't know that is just cynicism mixed with nostalgia. Wayland is something for future desktops, future devices, and future graphic cards. That might not include you over there on your 4 billion strong linux farm or on your local library desktop system or whatever. No one is saying that everyone has to move to Wayland. Now if you want to stay current with where all the major developers are going, then yeah, you're going to need to rethink your think. But FOSS allows minor players to play a role too and those minor players might not feel like moving on with the big boys. We all thought GNOME2 was dead and then MATE came along. And yeah the project is small but it's still actively maintained, and for the folks using it, it's enough for them.
This all plays into the bigger thing that's been a problem in Linux world. "Linux purity". Look, the popularity combined with the openness of Linux means that, there's going to be builds that move away from sysvinit, move away from X11, move away from things that we would commonly refer to as "Linux" (*cough*Android*cough*). There's way too many folks who are holding on to a made up idea of what "Linux" means. And this Wayland, Mir, Unity, GNOME3, systemd, and others are all flames that get started over someone's preconceived idea of what "Linux" means to them. They're still stuck in this war of, "if we don't unite, we'll never beat Microsoft" and they just hadn't noticed that the war is done, there's no one fighting anymore. People are "computering" differently now a days. Microsoft does not care about fighting Linux, they're more preoccupied with how to convince people to buy a Windows Phone or get on their cloud based service... Are mistakes going to be made along the way with Wayland/systemd/whatever stokes your fire? You bet'cha. X11 was a solution to a problem all the way up to when it became the problem. Wayland is a solution to X11's problem all the way up to when it will become the problem. And we'll invent something new then, and we'll invent something new to replace that, and on and on. One of the core things I was told when getting into the tech industry was, "This industry changes at a pace that's usually faster than people's willingness to change." I get a lot of people want to throw the usual "change for change's sake" argument as justification for why we don't need to fix something that's not broken. But we can either stagnate and find out all the fun that brings us or we can actually acknowledge we're in an industry that's always changing. Does that mean we're doing the right thing by changing? Well, no one knows that from the outset. And maybe moving to Wayland is a bad idea, but it's not a bad idea because X11 is a better option. It's not a bad idea because we should always do things the same way and never make better things. I can't readily think of a reason that makes Wayland a bad idea it's mostly aiming to do the thing we do now but better, and the number one reason I hear from a lot of people about is the whole network transparency thing. Typically it is just a misunderstanding of what X11/xserver actually do, or just up and up wrong, ill-contented, get off my grass thinking. But with anything, something is bound to crop up and sting Wayland in the ass, but the advent of 3D rendering and these massive cards that can do amazing things, is one of the multitude of things that stung X11 in the ass (multi-touch, the concept of a tablet and phone, etc being some other things), and there's no reason to just sit here and not see that. To just not notice that things are changing. We can either get on the bus or stick a fork in her and call it done as we watch everyone else fade off over the horizon.