Address soundness hole in cycle prevention

tests/task_patterns/combined.rs

@@ -45,7 +45,7 @@ async fn test_all_three_task_patterns() {
     let y = dag.add_task(task_fn(|_: ()| async { 3 }));
 
     // Pattern 1: Stateless addition
-    let sum = dag.add_task(StatelessAdd).depends_on((&x, &y)); // 5 + 3 = 8
+    let sum = dag.add_task(StatelessAdd).depends_on((x, y)); // 5 + 3 = 8
 
     // Pattern 2: Read-only multiplication
     let doubled = dag.add_task(ReadOnlyMultiplier(2)).depends_on(sum); // 8 * 2 = 16
@@ -102,9 +102,9 @@ async fn test_parallel_execution() {
 
     // All three tasks should have run
     assert_eq!(counter.load(Ordering::SeqCst), 3);
-    assert_eq!(dag.get(&t1).unwrap(), 1);
-    assert_eq!(dag.get(&t2).unwrap(), 2);
-    assert_eq!(dag.get(&t3).unwrap(), 3);
+    assert_eq!(dag.get(t1).unwrap(), 1);
+    assert_eq!(dag.get(t2).unwrap(), 2);
+    assert_eq!(dag.get(t3).unwrap(), 3);
 }
 
 #[tokio::test]
@@ -115,7 +115,7 @@ async fn test_task_fn_with_captured_state() {
     let base = dag.add_task(task_fn(|_: ()| async { 5 }));
     let scaled = dag
         .add_task(task_fn(move |x: i32| async move { x * multiplier }))
-        .depends_on(&base);
+        .depends_on(base);
 
     dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
         .await

tests/task_patterns/readonly.rs

@@ -55,7 +55,7 @@ async fn test_readonly_state_with_input() {
     let dag = DagRunner::new();
 
     let input = dag.add_task(task_fn(|_: ()| async { 5 }));
-    let result = dag.add_task(ReadOnlyMultiplier(7)).depends_on(&input);
+    let result = dag.add_task(ReadOnlyMultiplier(7)).depends_on(input);
 
     dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
         .await
@@ -76,13 +76,13 @@ async fn test_readonly_state_multiple_uses() {
         offset: 5,
     };
 
-    let result1 = dag.add_task(config).depends_on(&input1);
+    let result1 = dag.add_task(config).depends_on(input1);
     // Note: Can't reuse config because it was moved, so create another
     let config2 = ReadOnlyConfig {
         multiplier: 3,
         offset: 5,
     };
-    let result2 = dag.add_task(config2).depends_on(&input2);
+    let result2 = dag.add_task(config2).depends_on(input2);
 
     dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
         .await

tests/task_patterns/stateless.rs

@@ -84,7 +84,7 @@ async fn test_stateless_basic() {
 
     let x = dag.add_task(task_fn(|_: ()| async { 10 }));
     let y = dag.add_task(task_fn(|_: ()| async { 20 }));
-    let sum = dag.add_task(StatelessAdd).depends_on((&x, &y));
+    let sum = dag.add_task(StatelessAdd).depends_on((x, y));
 
     dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
         .await
@@ -98,7 +98,7 @@ async fn test_stateless_single_input() {
     let dag = DagRunner::new();
 
     let input = dag.add_task(task_fn(|_: ()| async { 21 }));
-    let doubled = dag.add_task(StatelessDouble).depends_on(&input);
+    let doubled = dag.add_task(StatelessDouble).depends_on(input);
 
     dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
         .await
@@ -128,9 +128,7 @@ async fn test_stateless_multiple_inputs() {
     let text = dag.add_task(task_fn(|_: ()| async { "test".to_string() }));
     let flag = dag.add_task(task_fn(|_: ()| async { true }));
 
-    let result = dag
-        .add_task(StatelessFormat)
-        .depends_on((&num, &text, &flag));
+    let result = dag.add_task(StatelessFormat).depends_on((num, text, flag));
 
     dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
         .await
@@ -166,7 +164,7 @@ async fn test_stateless_mixed_with_stateful() {
     let y = dag.add_task(task_fn(|_: ()| async { 3 }));
 
     // Stateless multiplication
-    let product = dag.add_task(StatelessMultiply).depends_on((&x, &y));
+    let product = dag.add_task(StatelessMultiply).depends_on((x, y));
 
     // Stateful counter
     let counted = dag.add_task(Counter::new(10)).depends_on(product);
@@ -185,7 +183,7 @@ async fn test_stateless_chain() {
     let dag = DagRunner::new();
 
     let start = dag.add_task(task_fn(|_: ()| async { 0 }));
-    let step1 = dag.add_task(StatelessInc).depends_on(&start);
+    let step1 = dag.add_task(StatelessInc).depends_on(start);
     let step2 = dag.add_task(StatelessInc).depends_on(step1);
     let step3 = dag.add_task(StatelessInc).depends_on(step2);
 
@@ -206,7 +204,7 @@ async fn test_stateless_parallel() {
     let tasks: Vec<_> = (1..=5)
         .map(|i| {
             let source = dag.add_task(task_fn(move |_: ()| async move { i }));
-            dag.add_task(StatelessSquare).depends_on(&source)
+            dag.add_task(StatelessSquare).depends_on(source)
         })
         .collect();
 
@@ -229,7 +227,7 @@ async fn test_stateless_with_string_types() {
     let hello = dag.add_task(task_fn(|_: ()| async { "Hello, ".to_string() }));
     let world = dag.add_task(task_fn(|_: ()| async { "World!".to_string() }));
 
-    let greeting = dag.add_task(StatelessConcat).depends_on((&hello, &world));
+    let greeting = dag.add_task(StatelessConcat).depends_on((hello, world));
 
     dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
         .await