Convert ProcessorTransactionLog into a trait. (bevyengine#21476)

# Objective

- There was a TODO to make this type actually a trait.
- bevyengine#21409 introduced a test flake on WIndows (since the transaction log
file may not have been fully released by the time the next test ran),
and made tests create the `crates/bevy_asset/imported_assets/log` file.

## Solution

- Create two traits: `ProcessorTransactionLogFactory` and
`ProcessorTransactionLog`. The former creates the latter.
- Rewrite the test helper for asset processing to use a fake transaction
log that doesn't do anything.
- Note: pretty much the entire implementation was just reformatted into
the trait.
- Note: these transaction log methods are returning `BevyError` instead
of something like `std::io::Error`.

## Testing

- I ran the asset tests on repeat for a while (including with bevyengine#21433
where the flake was first seen and I was able to reproduce fairly
quickly). No issues!

Note: we could make a release notes for the fact that users can make
their own transaction logs, but this feature is primarily for unit
testing. Maybe a user could make a more robust transaction log, but it's
really not clear that it would be important for anyone.

Author: andriyDev

crates/bevy_asset/src/lib.rs

@@ -716,6 +716,9 @@ mod tests {
             AssetWatcher, Reader,
         },
         loader::{AssetLoader, LoadContext},
+        processor::{
+            AssetProcessor, LogEntry, ProcessorTransactionLog, ProcessorTransactionLogFactory,
+        },
         saver::AssetSaver,
         transformer::{AssetTransformer, TransformedAsset},
         Asset, AssetApp, AssetEvent, AssetId, AssetLoadError, AssetLoadFailedEvent, AssetMode,
@@ -741,6 +744,7 @@ mod tests {
         sync::Mutex,
     };
     use bevy_reflect::TypePath;
+    use bevy_tasks::BoxedFuture;
     use core::{marker::PhantomData, time::Duration};
     use crossbeam_channel::Sender;
     use futures_lite::AsyncWriteExt;
@@ -2289,6 +2293,52 @@ mod tests {
             },
         ));
 
+        /// A dummy transaction log factory that just creates [`FakeTransactionLog`].
+        struct FakeTransactionLogFactory;
+
+        impl ProcessorTransactionLogFactory for FakeTransactionLogFactory {
+            fn read(&self) -> BoxedFuture<'_, Result<Vec<LogEntry>, BevyError>> {
+                Box::pin(async move { Ok(vec![]) })
+            }
+
+            fn create_new_log(
+                &self,
+            ) -> BoxedFuture<'_, Result<Box<dyn ProcessorTransactionLog>, BevyError>> {
+                Box::pin(async move { Ok(Box::new(FakeTransactionLog) as _) })
+            }
+        }
+
+        /// A dummy transaction log that just drops every log.
+        // TODO: In the future it's possible for us to have a test of the transaction log, so making
+        // this more complex may be necessary.
+        struct FakeTransactionLog;
+
+        impl ProcessorTransactionLog for FakeTransactionLog {
+            fn begin_processing<'a>(
+                &'a mut self,
+                asset: &'a AssetPath<'_>,
+            ) -> BoxedFuture<'a, Result<(), BevyError>> {
+                Box::pin(async move { Ok(()) })
+            }
+
+            fn end_processing<'a>(
+                &'a mut self,
+                asset: &'a AssetPath<'_>,
+            ) -> BoxedFuture<'a, Result<(), BevyError>> {
+                Box::pin(async move { Ok(()) })
+            }
+
+            fn unrecoverable(&mut self) -> BoxedFuture<'_, Result<(), BevyError>> {
+                Box::pin(async move { Ok(()) })
+            }
+        }
+
+        app.world()
+            .resource::<AssetProcessor>()
+            .data()
+            .set_log_factory(Box::new(FakeTransactionLogFactory))
+            .unwrap();
+
         AppWithProcessor {
             app,
             source_dir,
@@ -2379,7 +2429,7 @@ mod tests {
     }
 
     #[cfg(feature = "multi_threaded")]
-    use crate::processor::{AssetProcessor, LoadTransformAndSave};
+    use crate::processor::LoadTransformAndSave;
 
     // The asset processor currently requires multi_threaded.
     #[cfg(feature = "multi_threaded")]