Mixin composition style

A (somewhat punctilious) question of style:

I'm writing an extension for a Java library to add Scala support. This
library has a module system where extensions create derived classes of
a Module type:

// java
public class Module {
public abstract void init(Context context);
}

Modules are registered using a driver object:

// java
Module m = new Module { ... }
Driver d = new Driver();
d.register(m);

My extension has many unrelated features, so I've created multiple
Module instances as traits:

// scala
trait FeatureA extends Module {
def init(context: Context) { ... }
}

trait FeatureB extends Module {
def init(context: Context) { ... }
}

Each of these registers individually just fine. But now I want to
provide pre-baked collections of features so that end users don't have
to register each feature individually. Unfortunately, this library's
module system does not support composition (modules cannot register
other modules).

I've developed and tested two different implementations to deal with
this, and I'm wondering if one or the other is "better"/more
idiomatic, or if there is a third way I haven't considered that's even
cleaner.

Implementation A: Trait linearization

One approach is to create a base trait with a no-op initializer, and
have all the traits extend it and call the superclass method:

trait GenModule extends Module {
def init(context: Context) { /* do nothing */ }
}

trait FeatureA extends GenModule {
override def init(context: Context) {
super.init(context)
// Local init
}
}

trait FeatureB extends GenModule {
override def init(context: Context) {
super.init(context)
// Local init
}
}

trait BakedFeatures extends FeatureA with FeatureB {}

Pros: Feature implementation is straightforward and understandable.
Cons: If a feature trait forgets to call super, including that feature
can break other features because they won't be registered. Also, trait
linearization can be unintuitive to new Scala users.

Implementation B: Mixin module composition

This is effectively a hand-rolled form of module composition, but
rather than having an uber-module declare all the sub-modules, each
module registers itself with the base class when it's mixed in.

trait GenModule extends Module {
val initializers = Seq.newBuilder[Context => Unit]
def init(context: Context) {
initializers.result().foreach(_(context))
}
}

trait FeatureA extends GenModule {
initializers += { context => /* Local init */ }
}

trait FeatureB extends GenModule {
initializers += { context => /* Local init */ }
}

trait BakedFeatures extends FeatureA with FeatureB {}

Pros: Features can't affect each other.
Cons: Feature traits no longer "look like" modules, but like something
else. Uses mutable state.

I'm leaning towards implementation B simply for reasons of feature
brevity, but second and third opinions are welcome.

Thanks,
Christopher