[I'm moving my comment from the flagged tree over here because I feel that it captures the spirit of my lament of Rust, and your interpretation of it being a pure endorsement of Zig, rather well.]

TL;DR: Yes! But Zig is a Stand-in for simpler languages, and while in its infancy, I can foresee it to be "done" and "fit into my head". Rust requires a suspension of disbelief that all this complexity can be tamed and "gotten right" with a leap of faith for the language, compiler and everybody in-between including myself, that I'm not confident enough in the "proofs" it provides.

To quote from Dijkstras essay "On the cruelty of really teaching computing science".

> Right from the beginning, and all through the course, we stress that the programmer's task is not just to write down a program, but that his main task is to give a formal proof that the program he proposes meets the equally formal functional specification. While designing proofs and programs hand in hand, the student gets ample opportunity to perfect his manipulative agility with the predicate calculus. Finally, in order to drive home the message that this introductory programming course is primarily a course in formal mathematics, we see to it that the programming language in question has not been implemented on campus so that students are protected from the temptation to test their programs. And this concludes the sketch of my proposal for an introductory programming course for freshmen.

There are more ways to proof correctness than through the type system alone.
Clojure programs are surprisingly high quality despite being dynamically typed.

I feel almost sorry to not write a lengthy counter rebuttal, but sadly I agree with everything you said!
Would I prefer Zig to have a strong type system? Absolutely! But the reason why I choose Zig as a comparator is not because I feel that it does a significantly better Job at correctness than Rust, neither do.

If I had to build something (computer)-verifiably correct I'd probably Idris with linear types or something, but that's not a real contender, and neither is Carp or Linear Haskell.

But I feel that with Zig I'd at least have the chance to proof the correctness of my program manually (with pen & paper). Although Zig is still heavily in flux it's simple and focused enough that it "being done", and me thus being able to understand it in its entirety, is at least visible on the horizon (especially if one compares the number of people working on Zig with the number of People working on Rust, although Carp might be an even better contender in that metric). With Rusts complexity that date is much further out into the future, if it is ever achievable. And even then I'm not sure that I could fit enough of the language into my head to be satisfied with the correctness of my proofs, ignoring the fact that it also has to fit into the compiler devs heads sufficiently to ensure that the compiler is behaving correctly.

My critique is that little of this complexity actually comes from the parts that make the language unique, non of it is essential, it's all incidental complexity.
It's in the macro system, the standard library, the hand-wavy semantics of "box" and compiler intrinsics, of magic low level traits, an overzealous module system, way to much fondness of abstractions and their removal by compiler magic, and a general nonchalantness towards C++'s complexity.