Not trying to make this sound like a value judgment, more an observation. But it makes you wonder, what do we lose by excessive abstraction.
Or like complaining people forgot how to use teletypes. We didn't have to keep using teletypes, and we didn't keep using them. Our Linux terminals are still modeled after teletypes, but not in a way that has anything to do with using a real teletype. You don't learn teletypes, you learn terminals (which to a medium extent are like teletypes).
It isn't like when people don't learn to add numbers or how Quicksort works or assembly code. Those are still fundamental truths that help people understand things. It's more like not learning to write Roman numerals, or not learning ALGOL 60. Nothing is really lost except the ability to read old things. You don't learn Roman numerals, you learn western Arabic numerals, and they're better, not worse. You don't learn ALGOL 60, you learn C11, and some people would argue whether it's better, but it's not worse.
Files are currently used to implement apps, but that can be seen as a transitional measure, like an OS that supports both files and raw disk access. A fully app-based OS without files, though not existing currently, would be possible.
Another idea the industry discarded was to make the disk a big SQL database, again without files.
UX prognosticators have been preaching for decades that anything that computer users find confusing should simply be hidden. Not made more clear, or easier to use, but just papered over so users can no longer identify a specific thing to complain about. It’s just like the weirdos who try to get rid of the address bar on web browsers every few years, but the filesystem haters have been a lot more successful, and computers are more confusing as a result. You don’t solve confusion by hiding it behind a thin layer of paint. All the same problems still exist, but there’s no longer a way for experts to even try to help. There are so many better ways to simplify computing than pretending it’s magic.
They figure that the less users know about how their device/software works the more dependent they are on developers who can then act as gatekeepers of what the user can and can't do even when the system is capable of much more. They don't want users doing things differently, or disabling things, or seeing what's going on under the hood. Keeping users ignorant, controlled, and dependent gives them a very secure feeling.
Phones aren't secretly using Roman numerals or tiny embedded abacuses though. If they were for whatever reason, there would be plenty of value in learning those systems.