My theory is that it's popular with back-end / OOP / Java / C# developers, because they're used to that kind of boilerplate and the boilerplate / number of files / separation of concerns gives them comfort and makes it "feel" good.
But also, like React, it's easier to find developers for it, and on a higher level this is more important than runtime performance etc. And continuity beats performance.
(I can't speak of its runtime performance or bundle size though)
We've also recently absorbed a vanilla(-ish) JS codebase largely developed by one dev which provides a point of comparison.
Angular has plenty of boilerplate and idiosyncrasy, but it being opinionated and "pattern-y" has advantages when you want devs who infrequently touch it to be able to jump in and make changes with some level of consistency.
Additionally -- and this is anecdotal, but I suspect it's a common part of working with a plain JS codebase -- tracking the flow of data through the Angular application is usually soooo much more straightforward, even when it involves navigating through many layers and files. The Angular codebase only has N types of things, and they tend to relate to each other in the same ways, and they're often quite explicit (such as explicitly defined component element names in HTML templates). In contrast the JS app has whatever it has built up with very few constraints keeping it consistent. Obviously that could be improved with discipline and structure, but reducing that requirement is one of the things a framework gets you.
I can't comment too much on React as my one experience working in a proper React codebase was in a team who were largely as clueless as me :)
All of the people tailgating are contributing to the congestion.
Adam Something has a video responding to it that's worth watching too: https://www.youtube.com/watch?v=oafm733nI6U
Putting my armchair psychoanalyst hat on: I think American society embeds a need to be the "winner", and are you winning if end up behind another driver who's contending for "your" spot?
If you've driven elsewhere for a while, you start noticing subtle driver differences, such as drivers who want to merge into your (slower) lane never braking to merge behind you and always accelerating to do so, even when you're at the tail end of a vehicle chain in your lane.
Comparing to the experience of being a passenger on a bike in Saigon, the level of cooperation there is way higher, possibly due to a sort of necessity. I had this feeling while observing traffic there, that, while the latency and throughput of the roads during high traffic times are still kinda awful, at least for bikes there's a slow continuous progress that simply wouldn't exist without cooperation.
Funnily enough, my experience driving in Los Angeles was distinctly not terrible. Traffic was usually good enough to drive in, though there was very little regard for the speed limit on the freeways! I suspect I may have just been lucky to miss the worst of the traffic.
There's some great discussion over on lobste.rs (https://lobste.rs/s/2zk3oe/pushing_pulling_three_reactivity), but I particularly recommend this link that someone posted there to a post that covers much of the same topic but in a lot more detail with reference to various existing libraries and tools and how they do things: https://lord.io/spreadsheets/
The format made for good lunchtime reading -- the care you put into making it easily readable shows. Are the illustrations actually hand-drawn? Looking forward to the next part(s) that you hinted at!