I don't know what you are even trying to say at this point. Could you explain what you mean in more detail? I'll explain where I'm coming from.
If you bundle DLLs with your program then you have a stable ABI automatically, because it's constant: something you bundle will never change its ABI, because it won't change in any way, because it's bundled. It's constant. Windows developers bundle all their dependencies with their programs. The result is that they don't have issues with their programs not working because the libraries they depend on have changed since they released the program. They might as well be statically linked.
There is nothing Windows-specific about doing this. You can statically link libraries on Linux and you can dynamically link to libraries that you bundle with your program. There's nothing stopping you from doing exactly the same thing that people do on Windows, and it will be just as stable.
The difference between the platforms is that Windows people do this and Linux people don't, I think mostly because they don't properly understand what a platform is in the Linux world. "Linux" as a platform is the kernel, and nothing else. You can't rely on any userspace libraries existing, not even libc. Or you could target glibc+Linux. That's a different platform, where you can assume that libpthread.so, libm.so, libdl.so and libc.so all exist, and some others. But you can't assume GTK+ will exist. Or you can target a particular distribution at a particular version. Then you are reliant on the particular distribution's stability guarantees. You can't expect it to run elsewhere, but you get access to a much wider array of libraries that you can expect to exist (by making non-base libraries dependencies of your RPM).
In all cases, ABI stability (the ability to update dependencies without rebuilding) is a property of the platform you target. To rely on a stable ABI, everything you target needs to provide that ABI stability. If you target a distribution like RedHat Enterprise Linux, then you get 10 years of ABI stability guaranteed. If you target Arch Linux, you don't: as far I understand, every package that depends on a library is expected to be rebuilt when the library is updated, if necessary. If you target Linux itself, or glibc + Linux, then you get ABI stability forever, and they go to extremes to give you that. But in turn you need to bundle any dependencies yourself, by whatever means you like. That doesn't mean you can't update those bundled dependencies when you update the program, of course.
