fix: allow @metric_scope sync wrappers to work inside asyncio event loops

[jaheyy]

Fixes #131

Summary

Add synchronous flush and environment resolution paths that work regardless of whether an event loop is running:

• resolve_environment_sync() in environment_detector.py — checks for a cached environment first, then detects whether an event loop is running. If no loop is running, uses asyncio.run(). If a loop is running, offloads the async resolution to a ThreadPoolExecutor to avoid the RuntimeError.
• flush_sync() in MetricsLogger — calls resolve_environment_sync() and flushes the context synchronously. Shares the same __flush_with_environment() helper as the async flush().
• Sync wrappers in metric_scope/__init__.py now call logger.flush_sync() instead of asyncio.run(logger.flush()).

The async flush() path is unchanged — this is purely additive for the sync codepath.

Testing

• 4 new tests covering resolve_environment_sync, flush_sync, and both sync function/generator wrappers inside a running event loop

Dependencies

⚠️ This PR is stacked on #136, as there would be merge conflict anyway. This PR contains one extra commit on top of it.

[seoberha]

flush_sync() calls the module-level resolve_environment_sync() directly, while the async flush() uses self.resolve_environment — the callable injected via the constructor. This means flush_sync silently ignores any custom resolver passed at construction time.

Could we have resolve_environment_sync accept an optional async callable that defaults to the module-level resolver?

So something like

def resolve_environment_sync(
    resolve: Optional[Callable[..., Awaitable[Environment]]] = None,
) -> Environment:
    if EnvironmentCache.environment is not None:
        return EnvironmentCache.environment
    coro_fn = resolve or resolve_environment
    try:
        asyncio.get_running_loop()
    except RuntimeError:
        return asyncio.run(coro_fn())
    else:
        with concurrent.futures.ThreadPoolExecutor(max_workers=1) as pool:
            return pool.submit(asyncio.run, coro_fn()).result()

Then flush_sync can pass through the instance's resolver:

def flush_sync(self) -> None:
    environment = resolve_environment_sync(self.resolve_environment)
    self.__flush_with_environment(environment)