Implement Size() measuring size estimation for execution cache

[timl3136]

What changed?
Implement Size() measuring size estimation for execution cache, add empty size estimation function for mutableState and shardContext

Why?
We want to modernize existing cadence common cache implement to a bytes-based system. That means we need to have a method to measure each entry (which is currently accepting any generic interface). We found the "Reflect" package provides a measuring function but runtime is too slow to be used in cache operations. Therefore, we will require all usages to implement the Size() function in their cache logic if they want to migrate to the new bytes-based system.

In order to seamless transition from the current cache system with an entry-based model, the implementation and rollout will be done in following phases:

1. Define the Sizeable interface
2. Implement Sizeable for cadence-history service
   a. Implement Size() for ExecutionCache <-- This PR
   b. Implement Size() for EventCache
3. Implement bytes-based cache system
4. Enable new cache system for usage in cadence-history service
5. Implement and enable new cache system for the remaining usages

How did you test it?
Unit tests

Potential risks
No risk since this PR only adds read-only function that is not used.

Release notes

Documentation Changes

[davidporter-id-au]

nit: I think, for greenfield stuff we prefer not to use suite code anymore?

[timl3136]

Thanks, I will change that to regular unit tests.

[davidporter-id-au]

I'd suggest putting this in a distinct interface and composing them:

eg:

// in a common place, I guess common/size/est.go might work, I don't feel strongly, but a place where it, but you may need to put associated stuff in a place where it can be referenced by all packages, so its own package in common seems reasonable.

// the general set of things you need to care about for size. In this case I guess it's just a single getter
type EstSize interface {
  Size() int
}

one reason this might be useful, is that for functionality depending on this, you may need to do more than just have a single size function. There's probably instances where you have an average case, worst case etc. There might be some need to extend it.

and later, in mutable state and elsewhere:

type MutableState interface {
		AddTransferTasks(transferTasks ...persistence.Task)
		AddTimerTasks(timerTasks ...persistence.Task)
		GetTransferTasks() []persistence.Task
		GetTimerTasks() []persistence.Task
		DeleteTransferTasks()
		DeleteTimerTasks()
		SetUpdateCondition(int64)
		GetUpdateCondition() int64
+              size.EstSize                     // any methods on this interface will be also required by mutable state
}

[timl3136]

Thanks, in this case, we have a Sizeable interface in cache.go which I think will work well here. Or do I need a interface that is separated from the cache?