Clean up message passing between `MessageHub`, `synchronization.Engine` and `compliance.Engine`

At the moment, message passing between MessageHub, synchronization.Engine and compliance.Engine is untyped, with the following disadvantages:

• it makes it hard to figure out where messages are flowing
• requires repeated, unnecessary type checks
• obfuscates the core logic thereby amplifying the probability of technical debt and edge cases

For examples:

• the MessageHub contains code to handle synced blocks, despite the fact that the synchronization.Engine hands synchronized blocks directly to the compliance.Engine
• Note the compliance engine converts block proposal to functionally exactly the same data structure as a SyncedBlock.
  • There is a semantic difference on how we received the block and whom to slash in case the block is invalid. At the moment, we encode this into the data type, despite it representing exactly the same thing (a block).
  • To me, it would make more sense, to have the MessageHub and the synchronization.Engine feeding blocks as exactly the same data structure to the compliance engine, but differently-named input methods (e.g. ProcessProposal vs ProcessSyncedBlock)
  • This would be possible without design modifications, because the MessageHub as well as the synchronization.Engine already know the compliance engine directly (we just obfuscate the compliance engine's type unnecessarily)

Start by tracing the message paths in engine/collection/message_hub/message_hub.go, engine/common/synchronization/engine.go, and engine/consensus/compliance/engine.go. Compare the block types with model/events/synchronization.go and inspect the existing compliance-engine entry points. Done means message flow is typed, redundant handling and conversions are removed, and proposal versus synchronized-block semantics remain distinct.