Fix session event handler unsubscription and add tests

The unsubscribe function was failing due to invalid function pointer comparisons.
Refactored handler registration to use unique IDs for reliable cleanup.

Tests verify:
- Multiple handlers can be registered and all receive events
- Unsubscribing one handler doesn't affect others
- Calling unsubscribe multiple times is safe
- Handlers are called in registration order
- Concurrent subscribe/unsubscribe is safe

Co-authored-by: nathfavour <116535483+nathfavour@users.noreply.github.com>

Author: SteveSandersonMS

go/session_test.go

@@ -0,0 +1,121 @@
+package copilot
+
+import (
+	"sync"
+	"testing"
+)
+
+func TestSession_On(t *testing.T) {
+	t.Run("multiple handlers all receive events", func(t *testing.T) {
+		session := &Session{
+			handlers: make([]sessionHandler, 0),
+		}
+
+		var received1, received2, received3 bool
+		session.On(func(event SessionEvent) { received1 = true })
+		session.On(func(event SessionEvent) { received2 = true })
+		session.On(func(event SessionEvent) { received3 = true })
+
+		session.dispatchEvent(SessionEvent{Type: "test"})
+
+		if !received1 || !received2 || !received3 {
+			t.Errorf("Expected all handlers to receive event, got received1=%v, received2=%v, received3=%v",
+				received1, received2, received3)
+		}
+	})
+
+	t.Run("unsubscribing one handler does not affect others", func(t *testing.T) {
+		session := &Session{
+			handlers: make([]sessionHandler, 0),
+		}
+
+		var count1, count2, count3 int
+		session.On(func(event SessionEvent) { count1++ })
+		unsub2 := session.On(func(event SessionEvent) { count2++ })
+		session.On(func(event SessionEvent) { count3++ })
+
+		// First event - all handlers receive it
+		session.dispatchEvent(SessionEvent{Type: "test"})
+
+		// Unsubscribe handler 2
+		unsub2()
+
+		// Second event - only handlers 1 and 3 should receive it
+		session.dispatchEvent(SessionEvent{Type: "test"})
+
+		if count1 != 2 {
+			t.Errorf("Expected handler 1 to receive 2 events, got %d", count1)
+		}
+		if count2 != 1 {
+			t.Errorf("Expected handler 2 to receive 1 event (before unsubscribe), got %d", count2)
+		}
+		if count3 != 2 {
+			t.Errorf("Expected handler 3 to receive 2 events, got %d", count3)
+		}
+	})
+
+	t.Run("calling unsubscribe multiple times is safe", func(t *testing.T) {
+		session := &Session{
+			handlers: make([]sessionHandler, 0),
+		}
+
+		var count int
+		unsub := session.On(func(event SessionEvent) { count++ })
+
+		session.dispatchEvent(SessionEvent{Type: "test"})
+
+		// Call unsubscribe multiple times - should not panic
+		unsub()
+		unsub()
+		unsub()
+
+		session.dispatchEvent(SessionEvent{Type: "test"})
+
+		if count != 1 {
+			t.Errorf("Expected handler to receive 1 event, got %d", count)
+		}
+	})
+
+	t.Run("handlers are called in registration order", func(t *testing.T) {
+		session := &Session{
+			handlers: make([]sessionHandler, 0),
+		}
+
+		var order []int
+		session.On(func(event SessionEvent) { order = append(order, 1) })
+		session.On(func(event SessionEvent) { order = append(order, 2) })
+		session.On(func(event SessionEvent) { order = append(order, 3) })
+
+		session.dispatchEvent(SessionEvent{Type: "test"})
+
+		if len(order) != 3 || order[0] != 1 || order[1] != 2 || order[2] != 3 {
+			t.Errorf("Expected handlers to be called in order [1,2,3], got %v", order)
+		}
+	})
+
+	t.Run("concurrent subscribe and unsubscribe is safe", func(t *testing.T) {
+		session := &Session{
+			handlers: make([]sessionHandler, 0),
+		}
+
+		var wg sync.WaitGroup
+		for i := 0; i < 100; i++ {
+			wg.Add(1)
+			go func() {
+				defer wg.Done()
+				unsub := session.On(func(event SessionEvent) {})
+				unsub()
+			}()
+		}
+		wg.Wait()
+
+		// Should not panic and handlers should be empty
+		session.handlerMutex.RLock()
+		count := len(session.handlers)
+		session.handlerMutex.RUnlock()
+
+		if count != 0 {
+			t.Errorf("Expected 0 handlers after all unsubscribes, got %d", count)
+		}
+	})
+}