Context.Scope is great for public APIs, but may cause extra allocations for low-level things

I think exposing Scope as the only way to attach a Context is great, but I think it would be good if the ContextStorage exposes a low-level APIs attach/detach or something similar that do not require a new object all the time.

Example:

  /**
   * Returns a {@link Runnable} that makes this the {@linkplain Context#current() current context}
   * and then invokes the input {@link Runnable}.
   */
  default Runnable wrap(Runnable runnable) {
    return () -> {
      try (Scope ignored = makeCurrent()) {
        runnable.run();
      }
    };
  }

This code needs 2 allocations (one for the return Runnable, and will do an allocation when makeCurrent is called), but we can in this case re-write this like:

  /**
   * Returns a {@link Runnable} that makes this the {@linkplain Context#current() current context}
   * and then invokes the input {@link Runnable}.
   */
  default Runnable wrap(Runnable runnable) {
    return () -> {
      Context toDetach = storage.attach(this);
      try () {
        runnable.run();
      } finally {
        storage.detach(toDetach);
      }
    };
  }

The attach/detach APIs are for example, probably we need better APIs for that and we need to think about them.

Start by reviewing the Context.Scope and ContextStorage APIs referenced in the issue, along with the wrap(Runnable) example. Clarify the proposed low-level attach/detach semantics and API shape before implementation. Done means an agreed design that reduces unnecessary Scope allocations without changing context restoration behavior.