C/C++: Modern C++, properly written, doesn't have the problems you attribute to it. (Granted, there's a lot of bad C++ code out there.) There's nothing inherently wrong with raw pointers if properly used, except that they offer facilities that should not be used (such as deletion). Treat them as non-owning, and std::unique_ptr and std::shared_ptr as expressing ownership. (It might be a good idea to write a nonowning_ptr that you can't delete through.) std::vector can be used to avoid buffer overflows (using .at() instead of [] regularly for subscripts). C++ is hardly problem-free, but it annoys me when people complain about things that have been fixed.
UNIX and Linux: There have been large, complicated, systems in competition. They lost. Currently, the only real competitor is Microsoft Windows. Meanwhile, people work on new operating systems. If one comes out considerably superior, it will have its chance in competition, and if Unix/Linux is the mess you claim it will have serious competitive advantages. I'm not sure what you want here (Multics back?).
Too much trusted software: This is a mess, all right, but it's not at the bottom. We're pretty much stuck with the NT/Unixlikes duopoly for large-scale deployments, but the way to address this issue is, simply, to write your programs not to ask for permissions you don't need. Applications can be modified and replaced. There are indirect ways, also. Vista introduced UAC, which isn't directly much good as security, but which punished applications that wanted too many privileges by annoying their users, creating market disincentives for permission-grabbing.
Lack of liability: This is not a software issue per se, but rather a market one. The solution is not to have legal standards for software liability, but to make companies more practically liable in general. If companies had to pay more for their screw-ups, they'd have incentive to get reliable software. This, and the trusted software issue above, are also issues in the software market. When first-to-market is more profitable than reliability and diminished attack surfaces, we get software that is buggy, easy to attack, and financially successful. There is value in buggy software, as long as the bugs aren't too bad