Add async methods to module trace

[lgxbslgx]

This patch adds two async methods to module trace which can be used by project moon. See moonbitlang/moon#276 for more information.

[peter-jerry-ye-code-review]

From the git diff output provided, here are three observations that might be worth considering:

1. Unused Import:

   +use std::future::Future;

   The import of std::future::Future is added but does not appear to be used anywhere else in the file. This import can be removed to avoid clutter and potential confusion.

2. Potential Unsafe Mutation:

   #[inline]
   #[allow(static_mut_refs)]
   pub async fn async_scope<T>(name: &'static str, f: impl Future<Output = T>) -> T {
       // Safety: accessing global mut, not threadsafe.
       unsafe {
           match &mut TRACE {
               None =>  f.await,
               Some(t) => t.async_scope(name, f).await,
           }
       }
   }

   The function async_scope accesses a mutable static variable TRACE in an unsafe block. This is potentially not thread-safe and could lead to race conditions if this function is called concurrently from different threads. Consider using thread-local storage or another mechanism to ensure safe concurrent access.

3. Async Scope Overhead:

   async fn async_scope<T>(&mut self, name: &str, f: impl Future<Output = T>) -> T {
       let start = Instant::now();
       let result = f.await;
       let end = Instant::now();
       self.write_complete(name, 0, start, end);
       result
   }

   The async_scope function measures the time taken by the future f but adds overhead by awaiting the future within the function. If f is a lightweight future, the timing might not accurately reflect the actual time taken by f due to the overhead of the async context switch and timing measurement itself. Consider if the timing is critical and if there might be a more accurate way to measure the time without the overhead of awaiting within the function.

These observations aim to help improve code quality and address potential issues that might impact the performance, safety, or clarity of the code.

[Young-Flash]

Thanks!