Add an helper to create the `instruction_sysvar` account

[L0STE]

Due to the nature of this sysvar, it's very hard to create an implementation that resemble the one currently used.

I don't have a "good" way of doing it at the moment, but this is the way that I currently do it:

//...
let (instruction_sysvar_pubkey, instruction_sysvar_account) = get_account_instructions_sysvar(&mut mollusk, &[]);
//..

fn get_account_instructions_sysvar(mollusk: &mut Mollusk, instructions: &[Instruction]) -> (Pubkey, AccountSharedData) {
    // Construct the instructions data from all instructions
    let mut data = construct_instructions_data(
        instructions.iter().map(|instruction| {
            BorrowedInstruction {
                program_id: &instruction.program_id,
                accounts: instruction.accounts
                    .iter()
                    .map(|meta| BorrowedAccountMeta {
                        pubkey: &meta.pubkey,
                        is_signer: meta.is_signer,
                        is_writable: meta.is_writable,
                    })
                    .collect(),
                data: &instruction.data,
            }
        }).collect::<Vec<_>>().as_slice()
    );

    // Find which instruction contains the sysvar account and at what position
    if let Some((ix_index, _)) = instructions.iter().enumerate()
        .find(|(_, instruction)| {
            instruction.accounts.iter()
                .any(|meta| meta.pubkey == INSTRUCTION_SYSVAR)
        }) 
    {
        store_current_index(&mut data, ix_index as u16);
    }

    // Set the account data
    let mut instruction_sysvar_account = AccountSharedData::new(
        mollusk
            .sysvars
            .rent
            .minimum_balance(data.len()),
        data.len(),
        &self::ID
    );
    instruction_sysvar_account.set_data_from_slice(&data);

    (INSTRUCTION_SYSVAR, instruction_sysvar_account)
}

[buffalojoec]

@L0STE thanks for creating this issue! I think your method looks pretty good, but you're right we don't want to stray too far away from the implementation in the actual runtime. However, different validator clients will implement this slightly differently, so as long as the result is the same, we can mock it out in the test environment.

I'll need a little bit of time to dig into this, but I don't see why we wouldn't go at least in the general direction you've suggested here. Nice work!!