FastDiscardOfDeltas scanning all nodes and properties on delete

[Josipmrden]

Memgraph version
v2.16

Environment
Ubuntu 22.04

Describe the bug
If any node has been deleted in the system, and the transaction is currently the only one running, it will go through the whole dataset and scan properties.

To Reproduce

1. Create 10M nodes in Memgraph
2. Create 10 indices on them
3. create 5 nodes independent of those indices, and put an index on them
4. do detach delete on those nodes

i.e.

CREATE CONSTRAINT ON (a:TestNode) ASSERT a.Id is UNIQUE;
Create Index on :TestNode;
Create Index on :TestNode(Id);

CREATE (n:TestNode{Id:1});
CREATE (n:TestNode{Id:2});
CREATE (n:TestNode{Id:3});
CREATE (n:TestNode{Id:4});
CREATE (n:TestNode{Id:5});

MATCH (n:TestNode) RETURN n;

MATCH (n:TestNode) DELETE n;
MATCH (n:TestNode) DETACH DELETE n;

ensure that you have enough number of nodes and properties in the system so you can mimick this

Expected behavior
The nodes should have been deleted fast

Additional context

void InMemoryStorage::InMemoryAccessor::FastDiscardOfDeltas(uint64_t oldest_active_timestamp,
                                                            std::unique_lock<std::mutex> /*gc_guard*/) {
  auto *mem_storage = static_cast<InMemoryStorage *>(storage_);

  // STEP 1 + STEP 2
  std::list<Gid> current_deleted_vertices;
  std::list<Gid> current_deleted_edges;
  GCRapidDeltaCleanup(current_deleted_vertices, current_deleted_edges);

  // STEP 3) skip_list removals
  if (!current_deleted_vertices.empty()) {
    // 3.a) clear from indexes first

THIS PART WILL GO OVER THE WHOLE DATASET
    std::stop_source dummy;
    mem_storage->indices_.RemoveObsoleteEntries(oldest_active_timestamp, dummy.get_token());
    auto *mem_unique_constraints =
        static_cast<InMemoryUniqueConstraints *>(mem_storage->constraints_.unique_constraints_.get());
    mem_unique_constraints->RemoveObsoleteEntries(oldest_active_timestamp, dummy.get_token());

    // 3.b) remove from veretex skip_list
    auto vertex_acc = mem_storage->vertices_.access();
    for (auto gid : current_deleted_vertices) {
      vertex_acc.remove(gid);
    }
  }

  if (!current_deleted_edges.empty()) {
    // 3.c) remove from edge skip_list
    auto edge_acc = mem_storage->edges_.access();
    auto edge_metadata_acc = mem_storage->edges_metadata_.access();
    for (auto gid : current_deleted_edges) {
      edge_acc.remove(gid);
      edge_metadata_acc.remove(gid);
    }
  }
}

I would also put the FastDiscardOfDeltas in a flag, so we can disable it optionally for users that are experiencing any issues. By default the fast discard would be turned on