fix(server/mcp): scope defer span.End inside loop iteration (googleapis#2558)

## Description

In `readInputStream()`, `defer span.End()` is called inside a `for`
loop. Since `defer` schedules execution when the enclosing **function**
returns (not the current loop iteration), all spans created per message
accumulate without ever being ended for the lifetime of the stdio
session.

For a long-lived stdio server, this means:
- **Memory leak**: span objects accumulate indefinitely
- **Incorrect traces**: spans are never properly closed, producing
misleading telemetry data

## Changes

Wrap the per-message processing logic in an immediately invoked function
expression (IIFE), so `defer span.End()` correctly fires at the end of
each iteration. This follows the same pattern already used in
`InitializeConfigs` (`server.go` lines 85-98) for scoping spans inside
loops.

## Test

All existing tests pass. The `TestStdioSession` test exercises
`readLine` and `write` on the stdio session. The `readInputStream` loop
is covered by the existing MCP endpoint tests that exercise the full
message processing pipeline.

Fixes googleapis#2549

Author: marlonbarreto-git

internal/server/mcp.go

@@ -195,31 +195,37 @@ func (s *stdioSession) readInputStream(ctx context.Context) error {
 			}
 			return err
 		}
-		// This ensures the transport span becomes a child of the client span
-		msgCtx := extractTraceContext(ctx, []byte(line))
 
-		// Create span for STDIO transport
-		msgCtx, span := s.server.instrumentation.Tracer.Start(msgCtx, "toolbox/server/mcp/stdio",
-			trace.WithSpanKind(trace.SpanKindServer),
-		)
-		defer span.End()
+		if err := func() error {
+			// This ensures the transport span becomes a child of the client span
+			msgCtx := extractTraceContext(ctx, []byte(line))
 
-		v, res, err := processMcpMessage(msgCtx, []byte(line), s.server, s.protocol, "", "", nil, "")
-		if err != nil {
-			// errors during the processing of message will generate a valid MCP Error response.
-			// server can continue to run.
-			s.server.logger.ErrorContext(msgCtx, err.Error())
-			span.SetStatus(codes.Error, err.Error())
-		}
+			// Create span for STDIO transport
+			msgCtx, span := s.server.instrumentation.Tracer.Start(msgCtx, "toolbox/server/mcp/stdio",
+				trace.WithSpanKind(trace.SpanKindServer),
+			)
+			defer span.End()
 
-		if v != "" {
-			s.protocol = v
-		}
-		// no responses for notifications
-		if res != nil {
-			if err = s.write(msgCtx, res); err != nil {
-				return err
+			v, res, err := processMcpMessage(msgCtx, []byte(line), s.server, s.protocol, "", "", nil, "")
+			if err != nil {
+				// errors during the processing of message will generate a valid MCP Error response.
+				// server can continue to run.
+				s.server.logger.ErrorContext(msgCtx, err.Error())
+				span.SetStatus(codes.Error, err.Error())
 			}
+
+			if v != "" {
+				s.protocol = v
+			}
+			// no responses for notifications
+			if res != nil {
+				if err = s.write(msgCtx, res); err != nil {
+					return err
+				}
+			}
+			return nil
+		}(); err != nil {
+			return err
 		}
 	}
 }