In case it helps, I tend to think of a trait as a way to bolt behaviour (and attributes if necessary) onto objects, without having to alter the existing inheritance tree for that object's class. So you can have lots of different objects that all include behaviour/attributes from a given trait (or multiple traits), even though they may all be instances of different parent classes. Traits can provide implementations of the methods they specify, or leave these to be implemented elsewhere if appropriate.
Traits are often presented by comparison to
Java interfaces, which is not much use if you don't use Java. But Java interfaces were a sort of halfway house attempt to do the same thing i.e. add behaviour to an existing class without changing the parent class, because Java (like Scala) does not allow multiple class inheritance. As with traits, a Java class can implement several interfaces.
A Java interface is a contract that defines the method signatures you want, but (unlike Scala traits) it does not include the implementations - you have to write these methods yourself in any class that implements that interface. If you have a commonly used interface, this means you can end up having to write essentially the same method implementations many times. Interfaces are used everywhere in Java: the idea is that you code to the interface e.g. you declare references in terms of the interface, not the specific implementation class, so that you can change the specific class that implements that interface underneath, without necessarily having to change the code that calls methods on that interface. This reduces coupling between different parts of your system and is generally regarded as a Good Thing.
Scala traits are a more flexible and powerful way to achieve the same goal of combining functionality regardless of class inheritance. For example, Scala's great Collections library is built on the flexibility of being able to mix in behaviour from various traits to provide a specific set of functionality for each Collection type (such as the various concrete implementations of the
Map trait) while still sharing common features as far as possible.