Rust traits actually do allow you to have "default" implementations of methods, which gives implementers of that trait the option to avoid defining the method themselves.
For example, the trait for overloading the equality operators `==` and `!=` contains two methods, `eq` and `ne`, but `ne` has a default implementation that simply calls `eq` and negates its output. This means you only need to implement one method to get both operators, though you retain the option to implement both manually if you'd like.
Of course, such default implementations are necessarily limited by the fact that a lone trait can assume very little about the type it's being implemented on.
Interfaces are more fundamental than classes. An interface is just a contract between a client and its dependencies. This could be as simple as a function signature (callables in Python), a set of methods supported (duck-typing in Ruby/Python/Javascript/Smalltalk, interfaces in Go, or traits in Rust), a set of syntactic forms that are valid (traits in the C++ STL), a set of type-deduction rules (typeclasses in Haskell), or a common message-passing and data-structure format (like Thrift, Protobufs, or Cap'n Proto).
A lot of folks would argue that class is the real mistake in Java & C++, because it conflates the notion of a common interface that can be passed around with means of sharing implementations of that interface. Now, we're obviously not going to get rid of classes in Java. But it's interesting that many of the newer languages like Go and Rust don't have this construct at all, instead promoting interfaces & traits to first-class entities and letting you specify implementation independently.