Add u64 ExecutionId type (vercel/turborepo#8771)

### Description

The plan for task-local Vcs is to extend the `RawVc` type into:

```
enum RawVc {
    TaskOutput(TaskId),
    TaskCell(TaskId, CellId),
    LocalCell(ExecutionId, LocalCellId),  // new variant!
}
```

Where `ExecutionId` is a globally unique value representing the current task execution. That will be used with runtime safety checks to ensure that a given `LocalCellId` (which is an index into a task-local arena/vec) is valid upon read.

https://www.notion.so/vercel/Resolved-Vcs-Vc-Lifetimes-Local-Vcs-and-Vc-Refcounts-49d666d3f9594017b5b312b87ddc5bff?pvs=4

This PR extends the `define_id` macro to support arbitrary integer types, and uses that to define `ExecutionId`.

### Testing Instructions

```
cargo nextest r -p turbo-tasks -p turbo-tasks-memory
```

crates/turbo-tasks/src/backend.rs

@@ -15,7 +15,7 @@ use auto_hash_map::AutoMap;
 use serde::{Deserialize, Serialize};
 use tracing::Span;
 
-pub use crate::id::BackendJobId;
+pub use crate::id::{BackendJobId, ExecutionId};
 use crate::{
     event::EventListener, manager::TurboTasksBackendApi, raw_vc::CellId, registry,
     ConcreteTaskInput, FunctionId, RawVc, ReadRef, SharedReference, TaskId, TaskIdProvider,

crates/turbo-tasks/src/id.rs

@@ -1,7 +1,7 @@
 use std::{
     fmt::{Debug, Display},
     mem::transmute_copy,
-    num::{NonZeroU32, NonZeroU64, TryFromIntError},
+    num::{NonZero, NonZeroU64, TryFromIntError},
     ops::Deref,
 };
 
@@ -10,10 +10,10 @@ use serde::{de::Visitor, Deserialize, Serialize};
 use crate::registry;
 
 macro_rules! define_id {
-    (internal $name:ident $(,$derive:ty)*) => {
-        #[derive(Hash, Clone, Copy, PartialEq, Eq, PartialOrd, Ord $(,$derive)*)]
+    ($name:ident : $primitive:ty $(,derive($($derive:ty),*))?) => {
+        #[derive(Hash, Clone, Copy, PartialEq, Eq, PartialOrd, Ord $($(,$derive)*)? )]
         pub struct $name {
-            id: NonZeroU32,
+            id: NonZero<$primitive>,
         }
 
         impl $name {
@@ -22,8 +22,8 @@ macro_rules! define_id {
             /// # Safety
             ///
             /// The passed `id` must not be zero.
-            pub unsafe fn new_unchecked(id: u32) -> Self {
-                Self { id: unsafe { NonZeroU32::new_unchecked(id) } }
+            pub unsafe fn new_unchecked(id: $primitive) -> Self {
+                Self { id: unsafe { NonZero::<$primitive>::new_unchecked(id) } }
             }
         }
 
@@ -34,7 +34,7 @@ macro_rules! define_id {
         }
 
         impl Deref for $name {
-            type Target = u32;
+            type Target = $primitive;
 
             fn deref(&self) -> &Self::Target {
                 unsafe { transmute_copy(&&self.id) }
@@ -44,9 +44,12 @@ macro_rules! define_id {
         /// Converts a numeric identifier to the wrapper type.
         ///
         /// Panics if the given id value is zero.
-        impl From<u32> for $name {
-            fn from(id: u32) -> Self {
-                Self { id: NonZeroU32::new(id).expect("Ids can only be created from non zero values") }
+        impl From<$primitive> for $name {
+            fn from(id: $primitive) -> Self {
+                Self {
+                    id: NonZero::<$primitive>::new(id)
+                        .expect("Ids can only be created from non zero values")
+                }
             }
         }
 
@@ -55,23 +58,18 @@ macro_rules! define_id {
             type Error = TryFromIntError;
 
             fn try_from(id: NonZeroU64) -> Result<Self, Self::Error> {
-                Ok(Self { id: NonZeroU32::try_from(id)? })
+                Ok(Self { id: NonZero::try_from(id)? })
             }
         }
     };
-    ($name:ident) => {
-        define_id!(internal $name);
-    };
-    ($name:ident, derive($($derive:ty),*)) => {
-        define_id!(internal $name $(,$derive)*);
-    };
 }
 
-define_id!(TaskId);
-define_id!(FunctionId);
-define_id!(ValueTypeId);
-define_id!(TraitTypeId);
-define_id!(BackendJobId);
+define_id!(TaskId: u32);
+define_id!(FunctionId: u32);
+define_id!(ValueTypeId: u32);
+define_id!(TraitTypeId: u32);
+define_id!(BackendJobId: u32);
+define_id!(ExecutionId: u64, derive(Debug));
 
 impl Debug for TaskId {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {