feat: Fixing the spans produced by agent calls to have the right parent spans

This change fixes an issue where OpenTelemetry spans generated during agent executions were not correctly associated with their parent spans, leading to fragmented traces.

### Core Changes

*   **Explicit Context Propagation**: Instead of relying on `Context.current()`, which can be unreliable in asynchronous RxJava streams, the OTel `Context` is now explicitly captured at entry points (like `Runner.runAsync`) and passed down through method signatures in `BaseAgent`, `BaseLlmFlow`, and `Functions`.
*   **RxJava Context Support**: Introduced `Tracing.withContext(Context)`, a new set of transformers (`FlowableTransformer`, etc.) that re-activates a captured OTel context during the subscription of reactive streams. This ensures that any work done inside `flatMap` or `concatMap` remains within the correct trace.
*   **Synchronous Scope Management**: Wrapped direct calls to plugins and tool callbacks in `try-with-resources` blocks using `context.makeCurrent()` to ensure the tracing context is active during synchronous execution.
*   **Tracing Enhancements**:
    *   Updated `TracerProvider` to propagate the agent name via a new `AGENT_NAME_CONTEXT_KEY`.
    *   Improved agent name retrieval from spans using reflection (supporting `ReadableSpan`) when it's not explicitly available in the context.
    *   Modified span lifecycle management to start the span immediately upon subscription setup (via `Flowable.defer`) rather than waiting for `doOnSubscribe`.

### Impacted Areas

*   **`BaseAgent` & `BaseLlmFlow`**: Now strictly pass the parent context to all internal stages (preprocessing, model calls, postprocessing, and callbacks).
*   **`Runner`**: Entry points for `runAsync` and `runLive` are now consistently wrapped in an `"invocation"` span that serves as the root for the agent's work.
*   **`PluginManager`**: Ensures that plugin-provided callbacks are executed within the trace context captured when the callback was triggered.
*   **`Functions`**: Tool execution, including before/after callbacks and response event building, is now correctly parented.

### Note on Reviewer Comments
The reviewer noted a `ComplianceLint` warning regarding pending files in `Functions.java` that needs to be addressed by taking a snapshot.

PiperOrigin-RevId: 879355958

Author: google-genai-bot

core/src/main/java/com/google/adk/agents/BaseAgent.java

@@ -29,6 +29,7 @@
 import com.google.errorprone.annotations.CanIgnoreReturnValue;
 import com.google.errorprone.annotations.DoNotCall;
 import com.google.genai.types.Content;
+import io.opentelemetry.context.Context;
 import io.reactivex.rxjava3.core.Completable;
 import io.reactivex.rxjava3.core.Flowable;
 import io.reactivex.rxjava3.core.Maybe;
@@ -312,38 +313,46 @@ public Flowable<Event> runAsync(InvocationContext parentContext) {
   private Flowable<Event> run(
       InvocationContext parentContext,
       Function<InvocationContext, Flowable<Event>> runImplementation) {
+    Context otelParentContext = Context.current();
+    InvocationContext invocationContext = createInvocationContext(parentContext);
+
     return Flowable.defer(
-        () -> {
-          InvocationContext invocationContext = createInvocationContext(parentContext);
-
-          return callCallback(
-                  beforeCallbacksToFunctions(
-                      invocationContext.pluginManager(), beforeAgentCallback),
-                  invocationContext)
-              .flatMapPublisher(
-                  beforeEventOpt -> {
-                    if (invocationContext.endInvocation()) {
-                      return Flowable.fromOptional(beforeEventOpt);
-                    }
-
-                    Flowable<Event> beforeEvents = Flowable.fromOptional(beforeEventOpt);
-                    Flowable<Event> mainEvents =
-                        Flowable.defer(() -> runImplementation.apply(invocationContext));
-                    Flowable<Event> afterEvents =
-                        Flowable.defer(
-                            () ->
-                                callCallback(
-                                        afterCallbacksToFunctions(
-                                            invocationContext.pluginManager(), afterAgentCallback),
-                                        invocationContext)
-                                    .flatMapPublisher(Flowable::fromOptional));
-
-                    return Flowable.concat(beforeEvents, mainEvents, afterEvents);
-                  })
-              .compose(
-                  Tracing.traceAgent(
-                      "invoke_agent " + name(), name(), description(), invocationContext));
-        });
+            () -> {
+              return callCallback(
+                      beforeCallbacksToFunctions(
+                          invocationContext.pluginManager(), beforeAgentCallback),
+                      invocationContext,
+                      otelParentContext)
+                  .flatMapPublisher(
+                      beforeEventOpt -> {
+                        if (invocationContext.endInvocation()) {
+                          return Flowable.fromOptional(beforeEventOpt);
+                        }
+
+                        Flowable<Event> beforeEvents = Flowable.fromOptional(beforeEventOpt);
+                        Flowable<Event> mainEvents =
+                            runImplementation
+                                .apply(invocationContext)
+                                .compose(Tracing.withContext(otelParentContext));
+                        Flowable<Event> afterEvents =
+                            callCallback(
+                                    afterCallbacksToFunctions(
+                                        invocationContext.pluginManager(), afterAgentCallback),
+                                    invocationContext,
+                                    otelParentContext)
+                                .flatMapPublisher(Flowable::fromOptional)
+                                .compose(Tracing.withContext(otelParentContext));
+
+                        return Flowable.concat(beforeEvents, mainEvents, afterEvents);
+                      });
+            })
+        .compose(
+            Tracing.traceAgent(
+                otelParentContext,
+                "invoke_agent " + name(),
+                name(),
+                description(),
+                invocationContext));
   }
 
   /**
@@ -387,7 +396,8 @@ private <T> ImmutableList<Function<CallbackContext, Maybe<Content>>> callbacksTo
    */
   private Single<Optional<Event>> callCallback(
       List<Function<CallbackContext, Maybe<Content>>> agentCallbacks,
-      InvocationContext invocationContext) {
+      InvocationContext invocationContext,
+      Context otelParentContext) {
     if (agentCallbacks.isEmpty()) {
       return Single.just(Optional.empty());
     }
@@ -397,25 +407,24 @@ private Single<Optional<Event>> callCallback(
 
     return Flowable.fromIterable(agentCallbacks)
         .concatMap(
-            callback -> {
-              Maybe<Content> maybeContent = callback.apply(callbackContext);
-
-              return maybeContent
-                  .map(
-                      content -> {
-                        invocationContext.setEndInvocation(true);
-                        return Optional.of(
-                            Event.builder()
-                                .id(Event.generateEventId())
-                                .invocationId(invocationContext.invocationId())
-                                .author(name())
-                                .branch(invocationContext.branch())
-                                .actions(callbackContext.eventActions())
-                                .content(content)
-                                .build());
-                      })
-                  .toFlowable();
-            })
+            callback ->
+                callback
+                    .apply(callbackContext)
+                    .map(
+                        content -> {
+                          invocationContext.setEndInvocation(true);
+                          return Optional.of(
+                              Event.builder()
+                                  .id(Event.generateEventId())
+                                  .invocationId(invocationContext.invocationId())
+                                  .author(name())
+                                  .branch(invocationContext.branch())
+                                  .actions(callbackContext.eventActions())
+                                  .content(content)
+                                  .build());
+                        })
+                    .toFlowable()
+                    .compose(Tracing.withContext(otelParentContext)))
         .firstElement()
         .switchIfEmpty(
             Single.defer(