Co-authored-by: Green Baneling <XgreenX9999@gmail.com>

…ependency

REVIEWER NOTE : Review #2162
first for context
## Linked Issues/PRs
Closes #2186 

## Description

This PR allows you to insert `Transaction` in the `TxPool v2` service
and so perform all the necessary verifications and the insertion.

### Changes in code logic from `TxPool v1`

- The verifications are performed in a new order specified in #2186. The
goal is to avoid making the computation heavy work if the simple checks
aren't valid. In this new version we also ensure that verifications are
done in order by having wrapper type around each step to allow only one
verification path.

- The insertion is performed in a separate thread pool, the goal is to
not block the pool on any verifications/insertions and to manage the
ressources we allocate to these works

- The insertion rules and conditions has change to the following : 
- A transaction with dependencies can collide only with one other
transaction
- A transaction without dependencies can collide with multiple
transaction
  - Rules to free up space for new transaction
- If a transaction is colliding with another verify if deleting the
colliding transaction and dependents subtree is enough otherwise refuses
the tx
- If a transaction is dependent and not enough space, don't accept
transaction
- If a transaction is executable, try to free has much space used by
less profitable transactions as possible in the pool to include it

- New limits on the size of the pool : `max_pool_bytes_size and
max_pool_gas`

### Changes from the base branch `txpool-v2`

All the tests has been refactored to be way more clearer to understand
and easier to read. They also now all follow the naming and the GWT
convention.

## Checklist
- [x] Breaking changes are clearly marked as such in the PR description
and changelog
- [x] New behavior is reflected in tests
- [x] [The specification](https://github.com/FuelLabs/fuel-specs/)
matches the implemented behavior (link update PR if changes are needed)

### Before requesting review
- [x] I have reviewed the code myself
- [x] I have created follow-up issues caused by this PR and linked them
here

---------

Co-authored-by: Green Baneling <XgreenX9999@gmail.com>

… get an error.

Handled more gracefully cases when transactions is not found the storage.
Improved performance of the collision check in the parents by collecting all parents once.
Removed dependency collections from the public API of the storage. Now we have a separate `has_dependencies` method.
Extracted the logic about collision verification to the Pool level.
Fixed the issues with `find_free_space` where we could subtract the same subtree several times.
Fixed the issues with non updating the `number_dependents_in_chain` and `dependents_cumulative_bytes_size`.
Changed the return type for `get` function to be `Option` instead of `Result`. Added handling of `None`.
Reworked `gather_best_txs` function to not abandon the old iteration and continue it instead since it is harder to manipulate the algorithm. But still it is still has the same worse complexity as before.
Minimized the number of places where we pass the storage and storage id. Instead, pass the `&StorageData`. It gurantees that the caller already got storage values from the storage(and handled cases when it is `None`). It is more safe from API perspective.

… creates a random graph and internal asserts catch the error or unexpected state. The tests verify at the end that all state is empty after full cycle of TxPoolV2 usage.

Fixed several issues found by the fuzzer.

Now `insert` method uses the output of the `can_insert_transaction` method. Now the logic is the same for insert and can insert(before it was a little bit different).

…ol instead of the storage. It allows to not bye aware of the collisions in the storage level.

Return the error earlier if transaciton has too many deodendencies

# Conflicts:
#	crates/services/txpool/src/transaction_selector.rs

…lify the algorithm and to nto waste a lot of resources on cyclies handling.

Removed subtracting of the collisions from the `can_fit_into_pool` method. Having this logic requires handling cases when collided transaction is sub transaction of the collision graph, or in the case of candidate graph in the `find_free_space` method.

Added graph itegrity check to be sure that its state it valid after all manipualtions.

Handle the case with zero inputs in stability test.

Re-wrote the `remove_node_and_dependent_sub_graph_recursion` to be a bfs algorithm instead of dfs.

… be super precise.

… node not found