Replace synchronized blocks with virtual-thread-friendly Lock in Future.find() (#2910)

I replaced synchronized blocks with `Lock` because of virtual threads.

More details: https://docs.oracle.com/en/java/javase/21/core/virtual-threads.html#GUID-04C03FFC-066D-4857-85B9-E5A27A875AF9

Similar to #2845

Author: Koziolek

vavr/src/main/java/io/vavr/concurrent/Future.java

@@ -32,6 +32,8 @@
 import java.util.concurrent.*;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
 import java.util.function.*;
 
 /**
@@ -178,8 +180,10 @@ static <T> Future<Option<T>> find(Executor executor, Iterable<? extends Future<?
             return run(executor, complete -> {
                 final AtomicBoolean completed = new AtomicBoolean(false);
                 final AtomicInteger count = new AtomicInteger(list.length());
+                final Lock lock = new ReentrantLock();
                 list.forEach(future -> future.onComplete(result -> {
-                    synchronized (count) {
+                    lock.lock();
+                    try {
                         // if the future is already completed we already found our result and there is nothing more to do.
                         if (!completed.get()) {
                             // when there are no more results we return a None
@@ -193,6 +197,8 @@ static <T> Future<Option<T>> find(Executor executor, Iterable<? extends Future<?
                                         }
                                     });
                         }
+                    } finally {
+                        lock.unlock();
                     }
                 }));
             });