Add From<Uuid> implementation for Handle<A> (bevyengine#21394)

## Objective

Closes bevyengine#21349

Provides an ergonomic way to create a `Handle<A>` from a `Uuid` at
runtime.

## Solution

Implements the `From<Uuid>` trait for `Handle<A>`, allowing users to
write:
```rust
let uuid = Uuid::new_v4();
let handle: Handle<Image> = uuid.into();
```

Instead of the current verbose approach:
```rust
let handle = Handle::<Image>::Uuid(uuid, PhantomData);
```

## Testing

- Added comprehensive test `from_uuid` that verifies:
  - Conversion from `Uuid` to `Handle<A>` works correctly
  - The resulting handle is a UUID variant
  - The handle ID matches the input UUID
  - Both `.into()` and explicit `From::from()` work
- All existing handle tests continue to pass
- Clippy and formatting checks pass

---------

Co-authored-by: Alice Cecile <[email protected]>
Co-authored-by: François Mockers <[email protected]>

Author: 3 people

crates/bevy_asset/src/handle.rs

@@ -268,6 +268,13 @@ impl<A: Asset> From<&mut Handle<A>> for UntypedAssetId {
     }
 }
 
+impl<A: Asset> From<Uuid> for Handle<A> {
+    #[inline]
+    fn from(uuid: Uuid) -> Self {
+        Handle::Uuid(uuid, PhantomData)
+    }
+}
+
 /// An untyped variant of [`Handle`], which internally stores the [`Asset`] type information at runtime
 /// as a [`TypeId`] instead of encoding it in the compile-time type. This allows handles across [`Asset`] types
 /// to be stored together and compared.
@@ -626,6 +633,15 @@ mod tests {
         assert_eq!(UntypedHandle::from(typed.clone()), untyped);
     }
 
+    #[test]
+    fn from_uuid() {
+        let uuid = UUID_1;
+        let handle: Handle<TestAsset> = uuid.into();
+
+        assert!(handle.is_uuid());
+        assert_eq!(handle.id(), AssetId::Uuid { uuid });
+    }
+
     /// `PartialReflect::reflect_clone`/`PartialReflect::to_dynamic` should increase the strong count of a strong handle
     #[test]
     fn strong_handle_reflect_clone() {