refactor: Reverted parallelisation of narrow brute-force

        ~NarrowBruteForce() override = default;

        CollisionInfo detect(Collider* collider_a, Collider* collider_b) override {

            // Extract edges and faces into vectors for random-access iterators

            const auto& half_edges_set = collider_a->mesh()->half_edges();

            const auto& faces_set = collider_b->mesh()->faces();

            std::vector edges(half_edges_set.begin(), half_edges_set.end());

            std::vector faces(faces_set.begin(), faces_set.end());

            std::atomic_bool collision_found(false);

            // Parallel iteration over edges

            std::for_each(std::execution::par, edges.begin(), edges.end(), [&](const auto& edge) {

                if (collision_found.load(std::memory_order_relaxed)) {

                    return;

                }

            // Check if there is an edge on one collider, that intersects a face on the other collider

            for (const auto& edge : collider_a->mesh()->half_edges()) {

                for (const auto& face : collider_b->mesh()->faces()) {

                    const auto p1 = edge.lock()->start()->position_ws();

                    const auto p2 = edge.lock()->end()->position_ws();

                for (const auto& face : faces) {

                    // If another thread found a collision, break early.

                    if (collision_found.load(std::memory_order_relaxed)) {

                        break;

                    }

                    const auto face_vertices = face.lock()->vertex_positions();

                    if (geometry::line_triangle_intersection(p1, p2, face_vertices[0], face_vertices[1], face_vertices[2])) {

                        // Mark that a collision has been found

                        collision_found.store(true, std::memory_order_relaxed);

                        break;

                        return { {collider_a, collider_b}, true, false };

                    }

                }

            });

            return { {collider_a, collider_b}, collision_found.load(std::memory_order_relaxed), false };

            }

            return { {collider_a, collider_b}, false, false };

        }

        RayCastResult ray_cast(geometry::Ray ray, ConvexHullCollider* collider) override {