Epoch processing is too eager

[JustinDrake]

The current state transition function structure (as #1018 makes clear) is:

def state_transition(state: BeaconState, block: BeaconBlock) -> BeaconBlock:
    # Process slots (including those with no blocks) since block
    process_slots(state, block.slot)
    # Process block
    process_block(state, block)
    # Return post-state
    return state

def process_slots(state: BeaconState, slot: Slot) -> None:
    assert state.slot < slot
    while state.slot < slot:
        process_slot(state)
        # Process epoch on the last slot of every epoch
        if (state.slot + 1) % SLOTS_PER_EPOCH == 0:
            process_epoch(state)
        state.slot += 1

Notice on the last slot of every epoch, i.e. when (state.slot + 1) % SLOTS_PER_EPOCH == 0, process_epoch is run before process_block. This is bad because the attestations (and other operations such as eth1 votes) in the last block are ignored by process_epoch.

My best guess is that we want something like:

def state_transition(state: BeaconState, block: BeaconBlock) -> BeaconBlock:
    assert state.slot < block.slot
    while state.slot < block.slot:
        process_slot(state)
        if (state.slot + 1) == block.slot:
            process_block(state, block)
        if (state.slot + 1) % SLOTS_PER_EPOCH == 0:
            process_epoch(state)
        state.slot += 1
    return state

Notice that we are actually quite constrained:

1. process_slot must come first, to "catch up" the skip slots
2. process_block must come before the final process_epoch as highlighted by this issue

The above two imply that we want process_slot, then process_block, then the final process_epoch.