move "batch size estimation" biz-logic from SD to Exec (#19011)

reason: 
- it creating chicken-egg problem. Can't print in logs size before
commitment, then print after commitment - and understand how much data
produced commitment. Because "print after" will show over-estimated
size.
- SD is now having less and less biz-logic. So, `EstimateSize` it's
clearly abstraction-leak

Before this change i see:
```
buf=512M before commitment
buf=9G after commitment
```
but it's not because Commitment producing so much data 
it's because we "double-estimate": using estimation logic which
"predicting RAM usage after Commitment - before commitment", use same
prediction "after Commitment" is incorrect - because "we just know how
much RAM we using now".

Author: AskAlexSharov

db/state/execctx/domain_shared.go

@@ -240,7 +240,7 @@ func (sd *SharedDomains) ClearRam(resetCommitment bool) {
 	sd.mem.ClearRam()
 }
 
-func (sd *SharedDomains) SizeEstimate() uint64 {
+func (sd *SharedDomains) Size() uint64 {
 	return sd.mem.SizeEstimate()
 }
 

db/state/temporal_mem_batch.go

@@ -254,10 +254,7 @@ func (sd *TemporalMemBatch) GetAsOf(domain kv.Domain, key []byte, ts uint64) (v
 func (sd *TemporalMemBatch) SizeEstimate() uint64 {
 	sd.latestStateLock.RLock()
 	defer sd.latestStateLock.RUnlock()
-
-	// multiply 2: to cover data-structures overhead (and keep accounting cheap)
-	// and muliply 8 more: for Commitment calculation when batch is full
-	return uint64(sd.metrics.CachePutSize) * 16
+	return uint64(sd.metrics.CachePutSize)
 }
 
 func (sd *TemporalMemBatch) ClearRam() {

execution/stagedsync/exec3_metrics.go

@@ -592,7 +592,7 @@ func (p *Progress) LogExecution(rs *state.StateV3, ex executor) {
 	curTaskGasPerSec := int64(float64(curTaskGas) / seconds)
 
 	uncommitedGas := uint64(te.executedGas.Load() - te.committedGas.Load())
-	sizeEstimate := rs.SizeEstimate()
+	sizeEstimate := rs.SizeEstimateBeforeCommitment()
 
 	switch ex.(type) {
 	case *parallelExecutor:
@@ -874,7 +874,10 @@ func (p *Progress) log(mode string, suffix string, te *txExecutor, rs *state.Sta
 	var vals []any
 
 	if mode == "done" {
-		vals = []any{"in", interval}
+		vals = []any{
+			"in", interval,
+			"buf", fmt.Sprintf("%s/%s", common.ByteCount(rs.SizeEstimateAfterCommitment()), common.ByteCount(p.commitThreshold)),
+		}
 	}
 
 	vals = append(vals, []any{

execution/stagedsync/exec3_parallel.go

@@ -257,7 +257,7 @@ func (pe *parallelExecutor) exec(ctx context.Context, execStage *StageState, u U
 						lastBlockResult = *applyResult
 					}
 
-					flushPending = pe.rs.SizeEstimate() > pe.cfg.batchSize.Bytes()
+					flushPending = pe.rs.SizeEstimateBeforeCommitment() > pe.cfg.batchSize.Bytes()
 
 					if !dbg.DiscardCommitment() {
 						if !dbg.BatchCommitments || shouldGenerateChangesets || lastBlockResult.BlockNum == maxBlockNum ||

execution/stagedsync/exec3_serial.go

@@ -215,7 +215,7 @@ func (se *serialExecutor) exec(ctx context.Context, execStage *StageState, u Unw
 				break
 			}
 			se.LogExecution()
-			isBatchFull := se.readState().SizeEstimate() >= se.cfg.batchSize.Bytes()
+			isBatchFull := se.readState().SizeEstimateBeforeCommitment() >= se.cfg.batchSize.Bytes()
 			needCalcRoot := isBatchFull || havePartialBlock
 			// If we have a partial first block it may not be validated, then we should compute root hash ASAP for fail-fast
 			// this will only happen for the first executed block

execution/state/rw_v3.go

@@ -275,11 +275,25 @@ func (rs *StateV3) applyLogsAndTraces4(tx kv.TemporalTx, txNum uint64, receipt *
 	return nil
 }
 
-func (rs *StateV3) SizeEstimate() (r uint64) {
-	if rs.domains != nil {
-		r += rs.domains.SizeEstimate()
+// SizeEstimateBeforeCommitment - including esitmation of future ComputeCommitment on current state changes
+func (rs *StateV3) SizeEstimateBeforeCommitment() uint64 {
+	if rs.domains == nil {
+		return 0
 	}
-	return r
+	sz := rs.domains.Size()
+	sz *= 2 // to cover data-structures overhead: map, btree, etc... and GC overhead (clean happening periodically)
+	sz *= 2 // for Commitment calculation when batch is full
+	return sz
+}
+
+// SizeEstimateAfterCommitment - not including any additional estimations. Use it after ComputeCommitment calc - to see
+func (rs *StateV3) SizeEstimateAfterCommitment() uint64 {
+	if rs.domains == nil {
+		return 0
+	}
+	sz := rs.domains.Size()
+	sz *= 2 // to cover data-structures overhead: map, btree, etc... and GC overhead (clean happening periodically)
+	return sz
 }
 
 type storageItem struct {