With classic (Java, C#, and C++ to some extent) OOP, one can model shared behavior and data between classes by making those classes inherit from some common (absctract) base class with the appropriate methods and data. By making the methods suitably granular, the base class can then make small tweaks to the shared behavior without causing code duplication.
In Rust, it is possible to implement shared behavior via traits with default method implementations, but this prevents any shared data that goes without that shared behavior in any reasonable way that I can think of. Additionally, this is problematic if one wants multiple default implementations of a single trait.
As such, I'm asking, in Rust, how can one have a trait with multiple default implementations and state that goes with each implementation? In classic OOP, I'd have one abstract base class for the trait, then abstract subclasses for each default implementation (with their own member variables), and then various concrete and final implementation classes. The default implementations could also be non-abstract and also non-final to act as concrete implementations in their own right.