It's not just encapsulated processes/sockets/mounts/whatever; it's the network of events, interactions and dependencies systemd creates among them too. The article I took the quote in my first post from has quite a few examples of non-intuitive behaviors of each unit type, and unusual consequences of specifying a dependency, some of which programs and tutorials in the wild rely on.
Even seemingly simple unit types aren't that easy to implement. Taking your example, encapsulating a socket for a "socket activated" service — which is just one of the unit types, and just one kind of unit type interaction (socket + service) — implies a means of holding that socket (so it's not lost if the process stops), and some glue between that and the process supervisor. AFAIK only s6 provides a general purpose file descriptor (not just socket) holder among non-systemd init systems. Dinit's
socket-listen: could be extended for that purpose, but currently only works for a very restricted subset of what people can do by matching socket and service units. There can also be interactions between sockets and other unit types, emulating which will require glue between the socket holder and the other arms of this hypothetical
Frankenstein monster systemd shim.
Even if some of these interactions are rarely used in practice (the fact that we have so many programs available on Artix with little to no patching is proof of that), and could be feasibly left out of the shim without breaking most programs, systemd's interfaces assume the program listening can and will make them happen, so it'll take an intelligent analysis, or compiling and running, to be sure if a program will be broken, which is not ideal.
I do agree systemd has some valuable UX lessons, as well as features worth emulating, but keeping the same interface for programmers and writing shims is not a good idea, especially long-term.