Well, there's the moderate in the discussion! Many good points made on each side but that's a great point. There's been software like JX operating system that varied GC's on a per-component basis. There was also software such as Oberon work that mixed no-GC components with GC'd OS and tools. Exploring options that aren't all latency or throughput GC... including ability to eliminate GC effect in that... might lead to new paths that are exciting.

Outside this sub-field, another one that offers evidence of your opinion is static analysis vs dynamic checks. Full, memory safety for C programs originally required crazy overhead (300+% sometimes) with checks on all the things that could happen. Then, people started mixing static analysis with dynamic checks and clever architectures to reduce that overhead. They'd often use static analysis to determine when they could eliminate checks. I can see something similar happening with GC's where an analysis helps avoid bad operations. We already have a taste of it with Rust where we get some safety without GC.

C# has had value types for a long time. The conclusions the C# developers came to were that the tradeoffs are indeed the same as in previous languages.

For some reason people keep wanting to deny the generational hypothesis, in the hopes of not having to implement a generational GC. Frankly, this is wishful thinking. The generational hypothesis has been borne out again and again and again, in all kinds of different scenarios.