Bug: crash when hardware concurrency is exceeded about usearch HOT 5 CLOSED

  using namespace unum::usearch;

  // Create a metric and index
  const size_t kDimensions = 96;
  metric_punned_t metric(kDimensions, metric_kind_t::l2sq_k, scalar_kind_t::f32_k);

  // Generate and add vectors to the index
  const size_t kNumVectors = ReleaseVsDebugVsAsanVsTsan(100000, 20000, 15000, 10000);
  const size_t kNumIndexingThreads = 9;

  std::uniform_real_distribution<> uniform_distrib(0, 1);

  std::string index_path;
  {
    TestThreadHolder indexing_thread_holder;
    index_dense_config_t index_config;
    index_config.enable_key_lookups = false;
    index_dense_t index = index_dense_t::make(metric, index_config);
    index.reserve(index_limits_t(kNumVectors, kNumIndexingThreads));
    auto load_start_time = MonoTime::Now();
    CountDownLatch latch(kNumIndexingThreads);
    std::atomic<size_t> num_vectors_inserted{0};
    for (size_t thread_index = 0; thread_index < kNumIndexingThreads; ++thread_index) {
      indexing_thread_holder.AddThreadFunctor(
          [&num_vectors_inserted, &index, &latch, &uniform_distrib]() {
            std::random_device rd;
            size_t vector_id;
            while ((vector_id = num_vectors_inserted.fetch_add(1)) < kNumVectors) {
              auto vec = GenerateRandomVector(kDimensions, uniform_distrib);
              ASSERT_TRUE(index.add(vector_id, vec.data()));
            }
            latch.CountDown();
          });
    }
    latch.Wait();
    auto load_elapsed_usec = (MonoTime::Now() - load_start_time).ToMicroseconds();
    ReportPerf("Indexed", kNumVectors, "vectors", kDimensions, load_elapsed_usec,
               kNumIndexingThreads);

    // Save the index to a file
    index_path = GetTestDataDirectory() + "/hnsw_index.usearch";
    ASSERT_TRUE(index.save(index_path.c_str()));
  }

    thread_lock_t thread_lock_(std::size_t thread_id) const {
        if (thread_id != any_thread())
            return {*this, thread_id, false};

        available_threads_mutex_.lock();
        thread_id = available_threads_.back();  // Crashes here
        available_threads_.pop_back();
        available_threads_mutex_.unlock();
        return {*this, thread_id, true};
    }

result.available_threads_.resize(hardware_threads);