refactor: replace string-based emitter with type-safe generic event system

Refactors the event emitter system from string-based messages to a
type-safe generic implementation using typed events. Consolidates
separate tracker packages into a unified plugins architecture.

Changes:
- Replace Emitter with BaseEmitter[E comparable] using generics
- Add Event type with StartEvent, StepEvent, and StopEvent constants
- Create Listener[E] interface with BaseListener implementation
- Consolidate explanation, performance, and statistics trackers into
  internal/plugins package
- Simplify main CLI by using plugin constructors instead of manual
  event subscription
- Add Items() iterator method to Set for idiomatic range loops

pkg/emitter/emitter.go

@@ -2,53 +2,38 @@ package emitter
 
 import "git.maximhutz.com/max/lambda/pkg/set"
 
-type Observer struct {
-	fn      func()
-	message string
-	emitter *Emitter
+type Emitter[E comparable] interface {
+	On(string, func()) Listener[E]
+	Off(Listener[E])
+	Emit(E)
 }
 
-type Emitter struct {
-	listeners map[string]*set.Set[*Observer]
+type BaseEmitter[E comparable] struct {
+	listeners map[E]*set.Set[Listener[E]]
 }
 
-func Ignore[T any](fn func()) func(T) {
-	return func(T) { fn() }
+func (e *BaseEmitter[E]) On(kind E, fn func()) Listener[E] {
+	if e.listeners[kind] == nil {
+		e.listeners[kind] = set.New[Listener[E]]()
+	}
+
+	listener := &BaseListener[E]{kind, fn}
+	e.listeners[kind].Add(listener)
+	return listener
 }
 
-func (e *Emitter) On(message string, fn func()) *Observer {
-	observer := &Observer{
-		fn:      fn,
-		message: message,
-		emitter: e,
+func (e *BaseEmitter[E]) Emit(event E) {
+	if e.listeners[event] == nil {
+		e.listeners[event] = set.New[Listener[E]]()
 	}
 
-	if e.listeners == nil {
-		e.listeners = map[string]*set.Set[*Observer]{}
-	}
-
-	if e.listeners[message] == nil {
-		e.listeners[message] = set.New[*Observer]()
-	}
-
-	e.listeners[message].Add(observer)
-	return observer
-}
-
-func (o *Observer) Off() {
-	if o.emitter.listeners[o.message] == nil {
-		return
-	}
-
-	o.emitter.listeners[o.message].Remove(o)
-}
-
-func (e *Emitter) Emit(message string) {
-	if e.listeners[message] == nil {
-		return
-	}
-
-	for listener := range *e.listeners[message] {
-		listener.fn()
+	for listener := range e.listeners[event].Items() {
+		listener.Run()
+	}
+}
+
+func New[E comparable]() *BaseEmitter[E] {
+	return &BaseEmitter[E]{
+		listeners: map[E]*set.Set[Listener[E]]{},
 	}
 }