Add cost model

[gabotechs]

This is one PR from the following stack of PRs:

• No eager buffering in network connections #477
• Add NetworkBoundaryBuilder argument to inject_network_boundaries #463
• Add MaxGauge metric #464
• Lazily set the producer head at execution time #478
• Refactor task spawner into QueryCoordinator and StageCoordinator #479
• Add cost model #486 <- you are here
• Adaptive task count assignation #432

---

Mostly rescued from:

• Cost based planning #311

This PR is pretty big, but the whole purpose is to expose a very simple function:

pub(crate) fn calculate_cost(plan: &Arc<dyn ExecutionPlan>, cfg: &DistributedConfig) -> Result<usize>;

While keeping everything else private to the rest of the codebase.

---

This PR introduces a cost model used in Adaptive task count assignation, that attributes a compute cost to a plan based on:

1. The Statistics available by normal DataFusion mechanisms (ExecutionPlan::partition_statistics())
2. The compute time complexity of the different operators in a plan

The whole meat of this PR lives in the src/distributed_planner/statistics/compute_per_node.rs file: it's in charge of attributing a time complexity to the different ExecutionPlan implementations using big O notation. For example:

        let plan = plan_costs(r#"SELECT * FROM weather WHERE "MinTemp" > 5"#, 1).await;
        assert_snapshot!(plan, @r"
        O((out_Cols+Col0)) | FilterExec: MinTemp@0 > 5
         O(out_Cols) | DataSourceExec: file_groups={...}
        ");

In this example:

• DataSourceExec needs to allocate all the RecordBatches for all the output columns, as it's the data source, so it's time complexity is O(out_Cols), as its compute complexity linearly scales with the amount of columns it needs to allocate.
• FilterExec needs to:
  1. Perform a linear predicate evaluation over the MinTemp column (O(Col0))
  2. Allocate full new RecordBatches for all output columns based on rows filtered by the evaulated predicate (O(out_Cols))

The tests in compute_per_node.rs contains several examples of this for the different operators, which can go from pretty simple (FilterExec, ProjectionExec), to very complex (HashJoinExec).

Once the time complexity in big O notation is attributed to a node, doing a simple multiplication math of the columns appearing in the notation by the estimated byte_size of those columns (given by Statistics), gives the compute cost measured in bytes.