The real reason inheritance gets heavily used is that it’s the only way to do polymorphism in languages with really naive static nominal typing (like Java).
With structural typing, you’ve basically separated out interface from implementation, so you don’t need to have any preplanned assocation between different implementations (let alone a hierarchy). With derived types, you don’t need to actually declare which types you take, so you don’t need to abuse the type system to allow more than you’re technically allowed to pass (by creating a do-nothing interface to group together types unrelated except in what you want them for). Duck typing is basically the same thing as structural typing, only with type errors identified at runtime rather than at compile time. So, again, if you have duck typing then polymorphism doesn’t matter much so you don’t need inheritance.
The same flaws in type systems that make formalized inheritance useful for external code make it less useful as a code reuse mechanism. Types end up just being tags (meaningless on their own) associated with data, that must be manipulated in prescribed ways to appease the compiler. And the need to appease the compiler means — well, subclasses are liable to need to take different args to even shared functions! And, if you aren’t defining your own set of types for that, you can’t control their hierarchy in a language like this, so you can’t share code (even though the actual steps being performed are, likely, nigh-identical). A non-issue in derived-type or structural-type languages.
