I think that you're arguing with a strawman here. I don't think anyone thinks that Rust is a be-all, end-all language to replace all use cases.
I think that all that is claimed are the following:
- GC is also not a be-all, end-all answer to memory and resource management; see the fact that C and C++ still exist when there are many GC'd languages to choose from
- Purely functional programming is also not a be-all, end-all answer to problems of memory management, resource management, and parallelism
- It is possible to provide performance characteristics, including a mental model to judge and tweak performance characteristics, similar to C or C++, without exposure to the very unsafe semantics that they have
- It is possible to provide higher level constructs and nice tools that are commonly used in functional programming in such a language conveniently, efficiently, and safely
- The tools used to provide such type and memory safety are also useful for forming better organization of code than you might have in either C, C++, or higher level GC'd languages; the notion of who owns an object, who has a unique borrowed reference to an object, and who has a shared immutable reference to an object is something that is not made explicit in most other languages, but can be very useful for keeping track of your semantics and rules about who is allowed to do what.
- This combination of high-level features, some good thought on API design, and tools that help you structure your code a little better, can also mean that Rust is suitable to use beyond the the use cases that you might expect if you just focus on point 3. Point 3 is what most people think of as the reason for using Rust, the thing that makes it stand out, but the supply of reasonable high level abstractions, tools to help you reason a little better about ownership and sharing, and then some thoughtful API and ecosystem design around it, help make it appropriate for other tasks outside that core niche that differentiates it the most.
I don't think anyone thinks that Rust's approach is going to be employed everywhere, just that you shouldn't think of it as a one-trick pony for low-level, performance sensitive stuff where you want safety, and that it's actually applicable to a much broader range of applications.