docs(otel): register on the existing provider instead of replacing it

The usage snippet built a new sdktrace.TracerProvider and made it global.
For the flagship case — an ADK Go agent inside a service that already has
OpenTelemetry configured — this loses AI spans: the OTel global delegation
fires only once, so an already-installed provider's tracers (including
ADK's, cached at package init) stay bound to it and never reach the PostHog
processor, while the replacement provider also drops the user's resource,
sampler, and existing exporters. The README prose already said "register it
on your TracerProvider", which the code contradicted.

Show provider.RegisterSpanProcessor(processor) on the application's own
*sdktrace.TracerProvider, and shut down the processor (not the provider) so
PostHog's setup does not tear down the user's tracing pipeline. Keeps the
fresh-context, error-reported shutdown from the previous fix.

Generated-By: PostHog Desktop
Task-Id: 01e1bd45-4478-4317-8196-8ddfcfe917bf

Author: posthog[bot]

otel/README.md

@@ -16,29 +16,37 @@ go get github.com/posthog/posthog-go/otel
 
 ## Usage
 
-`SpanProcessor` is the recommended integration. Register it on your
-`TracerProvider`:
+`SpanProcessor` is the recommended integration. Register it on the
+`*sdktrace.TracerProvider` your application already owns — rather than replacing
+the global provider with a new one — so your resource, sampler, and existing
+exporters are kept and tracers already handed out (such as ADK Go's) route
+through it:
 
 ```go
 processor, err := posthogotel.NewSpanProcessor(ctx, "phc_your_project_api_key")
 if err != nil {
 	log.Fatal(err)
 }
-provider := sdktrace.NewTracerProvider(sdktrace.WithSpanProcessor(processor))
-otel.SetTracerProvider(provider)
 
-// Flush buffered spans on shutdown. Use a fresh context, not one that is
-// already canceled (for example from signal.NotifyContext): the SDK skips
-// the final export on a canceled context and silently drops queued spans.
+// provider is your existing *sdktrace.TracerProvider.
+provider.RegisterSpanProcessor(processor)
+
+// Shut down the processor — not your provider — to flush its buffered spans.
+// Use a fresh context, not one that is already canceled (for example from
+// signal.NotifyContext): the SDK skips the final export on a canceled context
+// and silently drops queued spans.
 defer func() {
 	shutdownCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
 	defer cancel()
-	if err := provider.Shutdown(shutdownCtx); err != nil {
-		log.Printf("shutdown tracer provider: %v", err)
+	if err := processor.Shutdown(shutdownCtx); err != nil {
+		log.Printf("shutdown posthog processor: %v", err)
 	}
 }()
 ```
 
+If you don't already have a `TracerProvider`, create one and register the
+processor on it, as [`example/`](example) does.
+
 Use `WithHost` for a host other than PostHog US cloud, for example
 `posthogotel.WithHost("https://eu.i.posthog.com")`.