Sorry, I admit I didn't read the whole thread yet (I will do that next), but I felt like responding first anyway.
I love the title you chose for this post, Rust IS definitely very hard to learn. I have learned not some of the oldest languages, but many other ones, and out of everything I studied, Rust was harder than all of those, and I didn't learn every aspect of it yet, even after studying it for about a year and even after using it for some real-world applications.
Although it is very hard to learn, there aren't too many parts of it that jump out at me as being things I would really want changed.
It's absolutely a valid criticism though, Rust being too hard to learn, and it's preventing the language from being used in more software houses, but I personally don't care about this, because it means I can put in the effort to learn something hard which other people won't bother learning, and then I can get ahead and get higher pay than others for the same amount of daily work in the places which do hire Rust programmers.
There is a good reason too (I am probably repeating others here, sorry) why it's hard to write code which compiles, and they outline that in the official free Rust book. The compiler wants more of the compile-time code to be correct, so that once we've moved to run-time, we can have more guarantees of various aspects of a program being correct and not crash-prone, or prone to other errors.
It's a trade-off, but to me a compiler error is much faster and easier to notice, fix, and validate, than most any kind of run-time bugs which would need certain conditions to be hit while the program is running and things needing to be watched through a debugger to validate the correctness. So I'm happy for those things in Rust, because less run-time debugging means a lot less annoying work and less unexpected bugs slipping through QA.
Regarding "LIFETIME HELL", I think it's not really hell, it's just an extra thing which many other languages don't give you explicit control over, so it's yet one more thing to have to think about when writing Rust code. But I think while it's not immediately intuitive, it becomes pretty simple to understand after practising writing some real-world Rust programs for maybe a month or two. It used to be worse too, these days in Rust, a lot of lifetimes can be automatically filled in when you want a default lifetime behaviour, it didn't used to be that simple in older versions of Rust.
I don't find the compiler messages nearly as cryptic as for example, the C++ compiler when it's complaining about template metaprogramming errors. One thing which is great about the Rust compiler error messages that a lot of other languages' compilers don't do, is it will often suggest other similarly named functions or variables when the one you put caused an error, and sometimes these suggestions have saved me a lot of time looking through various files to find the right name for something I had done wrong. It also usually gives at least two different line numbers to consider for any given error, something similar to "this thing you did on line NN is wrong, maybe because of this other thing over here on line MM". These bits of coding advice direct from the compiler error messages have been really helpful to me in learning how to write Rust code properly, and I love them.
Anyway, sorry if I repeated some things which other people already said. I will actually read the thread now.