Rust's memory model is by far its most significant advantage over C++, and it cannot be added to C++ without breaking all backwards compatibility.
In addition to that it also protects against the majority of multithreading issues - which is something not even available in managed languages like C# or Java.
Well I see your point, the reality is that this statement is also true of rust itself!
The features it gets now are all mostly on the roadmap since quite a bit and neither surprising nor do the feel like a huge pile of "everything I can imagine" thrown together.
Rust is several order of magnitudes away become such clogged like C++ is, and also its feature acquisition accelerates slower than the one of C++. The only thing slower than that acceleration is probably its compile speed, but here C++ isn't really better. :)
From observing both since a bit I just really got the feeling that rust adoption of things was more thought out to fit the existing language and ecosystem, not 100% perfect, but much more fitting than what C++ did, i.e., mixing in every thing they could get their hands on, while some actually made things better, a lot just do not go well when being together.
In my modern C++ projects, I only really need to know std::move and std::unique_ptr.
The real question to ask is how much complexity one's willing to pay for memory safety. I'm willing to pay it, but with open eyes about the complexity cost I'm paying.
If you're switching to C++ because of performance, you should have probably picked C++ instead from the beginning.
But many performance gains will be automatic e.g http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p072...
I really hope that Rust compiler team will investigate in great depth the expert changes in C++20 and backport the relevant stuff into rust