ReplayBloc function onTransition() handles event _Undo instead of user defined event

**Description**
While trying out the class `ReplayBloc` I encountered a problem when using the method `onTransition`. Instead of handling the user defined event `Rewind`, an internal event `_Undo` is handled. (The handler of `Rewind` calls `undo()`, see function `_rewind()` below.)

**Steps To Reproduce**
```Dart
import 'package:replay_bloc/replay_bloc.dart';
import 'package:equatable/equatable.dart';

/// Bloc state
final class CounterState extends Equatable {
const CounterState(this.i);
final int i;

@override
List get props => [i];
}

final class CounterInitial extends CounterState {
const CounterInitial() : super(0);
}

/// Bloc events
sealed class CounterEvent extends ReplayEvent {}

final class Increment extends CounterEvent {}

final class Decrement extends CounterEvent {}

final class Rewind extends CounterEvent{}

/// Bloc logic
class CounterBloc extends ReplayBloc {
CounterBloc() : super(CounterInitial()) {
on((event, emit) => switch (event) {
Increment() => emit(CounterState(state.i + 1)),
Decrement() => emit(CounterState(state.i - 1)),
Rewind() => emit(_rewind()),
});
}

CounterState _rewind() {
undo();
return state;
}

@override
void onTransition(
covariant Transition transition) {
super.onTransition(transition);
print(transition.event.runtimeType);

if (transition.event is Rewind) {
print(' Doing something during event Rewind. '); // <-------- Never reached.
}
}
}

/// Executable
void main(List args) {
final bloc = CounterBloc();

bloc.add(Increment());
bloc.add(Decrement());
bloc.add(Rewind());
}
```
**Expected Behavior**
```Terminal
$ dart main.dart
Increment
Decrement
Rewind
Doing something during event Rewind.
```

**Actual Behavior**
```Terminal
$ dart main.dart
Increment
Decrement
Undo
```

**Additional Context**
The fact that `_Undo` is private makes it more difficult to filter events in `onTransition`.