You’ve highlighted it pretty well. But you’re wrong about one thing.

Stable means the packages’ interfaces remain stable. I mean that term in a very broad sense; a GUI layout would be included in my definition of an interface here.

The only feasible way of achieving that goal is to freeze the versions of the software and abstain from updating it. This creates a lot of work because newsflash: The world around you is not stable (not at all). Some parts must be updated because of changes in the world around you. The most critical here is security patches. Stable distros do backport those but usually only bother porting “important” security patches because it’s so much effort.

Another aspect of this is that you usually can’t introduce support for these without risking breaking older interfaces, so stable distros simply don’t receive new features.

Windows 95 is one of the most stable operating systems in the world but there’s a reason you’re not using that (besides the security issues): At some point, you do need newer versions of interfaces to, well, interface with the world. There’s newer versions of software with additional features, new communications standards and newer hardware platforms that you might want/need.

As an example: Even if you backported and patched all security issues, Firefox from 10 years ago would be quite useless today as it doesn’t implement many of the standard interfaces that the modern web requires.

What you are wrong about though is that stable means no breakage or that things “run smoothly”. That’s not the case; stable only means that it’s the same sources of breakage and same level of roughness. No new sources of breakage are introduced by the distro but the existing ones remain.
Stable distros do try and fix some bugs but what is and isn’t a bug sometimes isn’t easily determined as one man’s bug is another man’s feature. If things weren’t running smoothly before, stable distros will ensure that they will run similarly roughly tomorrow but not any worse.
Well, for parts that the distro can control that is. Things outside the distro’s control will inevitably break. Tools made for interfacing with 3rd party services will break when those 3rd party services inevitably change their interface; regardless of how stable the distro is (or rather precisely because of how stable the distro is).

Stable interfaces and no local regressions are what characterises stable distros. Not “no breakage”, “system stability” or whatever; those qualities are independent of stable vs. fresh distros and a lot more nuanced.

“Stable” doesn’t necessarily refer to “reliable,” depending on the context. Stable is often used in reference to how often a distro releases new versions of the applications. Using Audacity as an example, in the current release of the distro, they’ll release security & bug fixes for version 2, but if you want version 3, you’ll have to wait until the next distro release.

Upgrades to a new version of an application can introduce new ways of using the app (i.e. icons in different places, how user-created files are written to disk, etc.), which is disruptive to enterprise op’s, which is why Debian & RHEL take this approach.

Hopefully that helps clarify things.