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]]{},
 	}
 }

pkg/emitter/listener.go

@@ -0,0 +1,19 @@
+package emitter
+
+type Listener[E comparable] interface {
+	Kind() E
+	Run()
+}
+
+type BaseListener[E comparable] struct {
+	kind E
+	fn   func()
+}
+
+func (l BaseListener[E]) Kind() E {
+	return l.kind
+}
+
+func (l BaseListener[E]) Run() {
+	l.fn()
+}

pkg/set/set.go

@@ -1,5 +1,7 @@
 package set
 
+import "iter"
+
 type Set[T comparable] map[T]bool
 
 func (s *Set[T]) Add(items ...T) {
@@ -34,6 +36,16 @@ func (s Set[T]) ToList() []T {
 	return list
 }
 
+func (s Set[T]) Items() iter.Seq[T] {
+	return func(yield func(T) bool) {
+		for item := range s {
+			if !yield(item) {
+				return
+			}
+		}
+	}
+}
+
 func New[T comparable](items ...T) *Set[T] {
 	result := &Set[T]{}