OpenCL is 'stuck' because Apple gave up. I understand that Apple was 'fed up' but that was a bit premature. OpenCL 3.0 came in 2020.
OpenCL is stuck because OpenCL is effectively dead. Khronos prodding the cadaver with an electrode once in a while doesn't make it more alive. Serious compute nowadays is all about proprietary frameworks: CUDA for Nvidia, HIP for AMD etc.
The push from others to weave OpenCL with C++ is another factor to why Apple is walking away. There is a Swift (and previously ObjectiveC ) agenda pushes regardless of where the rest o the HPC market is going.
I don't think Apple is averse to C++ as such. Metal Shading language is based on C++ 11 and Apple recently released C++ bindings to Metal. They are also generally quick with keeping up with latest C++ standards and they use C++ internally quite a lot.
But you mention a very interesting topic here. CUDA has popularised using C++ based DSLs to mix CPU and GPU code in the same source, and initiatives like SYCL are coping this approach. Personally, I am not a big fan. This model is targeting a typical HPC programmer who just wants to write some code and not to care about interfacing details (another technology that's similar in spirit is OpenMP, and I dislike it for similar reasons). But this convenience comes at a high cost. These tools lump too many things together, they lack tooling flexibility, leave you at the mercy of the framework implementor, and of course, they mess with the C++ standards.
The main reason why this model became so popular is because low-level interfacing in traditional APIs is just so incredibly awful. Merely sending some data to GPU and back can be a total nightmare. A C++ dev doesn't want to deal with dozens or more of API calls and difficult to understand synchronisation primitives. To put differently, it's not that CUDA is that good, but that GPU APIs are that awful.
Metal programming model is much more interesting to me, as it keeps the execution domains separate (and thus gives you more flexibility), but massively simplifies the interfacing between them. In this, Metal follows the well understood and conceptually simple shared memory RPC model. Apple can (and should) still make things easier. First, they should introduce unified virtual memory, so that pointers don't need to be marshalled between execution domains. Second, the interfacing API can still be made simpler. For example, keep the separation between CPU and GPU code at the source level (just like web does with JS and CSS), but add some syntactic sugar for importing GPU kernels as native functions. I think just implementing these two things will massively improve the GPU programming experience on Apple platforms without suffering from the same issues as other frameworks.
Worse case Apple has taken the "we're big enough people have to eat whatever dogfood we provide" stance. A Metal (and no alteratives) stances isn't going to help in attracting 3rd party GPU vendors to come to the platform at all. Combined with Apple hyper focused on throwing dGPUs out of as many Mac systems as possible as the default GPU. It is just a very small market for which even less code is portable too.
You are most likely spot on with this description of Apple strategy. However, I don't share your pessimism. There is evidence that their strategy is working, albeit slowly. In the last two years we saw popular framework implementing Metal backends. Sure, most of this was sponsored by Apple, but it's pretty much the first time that one can really use GPU-accelerated machine learning or rendering on a Mac.