I have read in several places that having one programming language mechanism that conflates both is a bad thing. [...] So why is this a bad thing?
Because in situations where one wants one of them and not the other, one is left without an option (a recast of the "wanted a banana but what you got was a gorilla holding the banana and the entire jungle" problem, to import a famous quote). "subclass" as presented in many languages is an operation that "means a lot", that has "too much operations" within, with an "all or nothing" requirement.
Example #1: Suppose a type
A is introduced by a declaration of a "fat" class
A -- a class whose instances take a large amount of memory.
Now suppose in this system a new subtype of
A is required (call it
B), which "extends"
A with extra operations used in a new area of the system, but whose values should be also used in old areas (where values of type
A are expected). The final requirement for
B is that even though values of this type strictly conforms to
A's "contract", these values do not need to -- or even must not -- take much memory.
In a language where both operations are conflated in a "subclass" operation, there is no option: to have a subtype of
A used where
A is expected, one has to subclass
A, and by subclassing
A, one brings to the subclass a bunch of things that are not only irrelevant to the subclass, but explicitly undesired. You wanted just the type, but got the structure as well.
Example #2: There's the other way around too. That is, a class
A exists in a system, and one wants to create a new structure
B based on
A but whose semantics, for some reason, will depart from
A's "contract" in some sensible way. Because of that violation, for safety's sake (or even semantics sake) it is expected that values of type
B should not be allowed to be used where values of type
A are expected (and vice-versa). Again, with only a generic "subclass" operation, this option is not available. You want just the structure, but will get the type as well.
While this is commonly worked around using an encapsulated value of type
B (otherwise known as "composition"), one is forced to write all the artificial glue code that wouldn't be necessary otherwise.