Public Kernel - Update side effect counter after nested call

[MirandaWood]

In public -> public nested calls, the context currently increments the side effect counter by 1 rather than extracting the updated counter from the call itself (in public_context.nr):

    pub fn call_public_function_with_packed_args<RETURNS_COUNT>(
     <....>
    ) -> FunctionReturns<RETURNS_COUNT> {
        let side_effect_counter = self.side_effect_counter;
        // TODO get next value from output of `call_public_function_internal`
        self.side_effect_counter += 1;

        let raw_returns = call_public_function_internal(
            <...>
        );

        FunctionReturns::new(raw_returns)
    }

This causes issues as the nested call may increase the side effect counter by more than one. In private_context.nr we return a call stack item from the internal call oracle, and extract the updated counter, and increment to account for the call itself being a side effect:

self.side_effect_counter = item.public_inputs.end_side_effect_counter + 1;

The public call oracle only returns the return values of the nested call. To have it also return the side effect counter probably requires arithmetic on generics (to set the fn to return an array of RETURN_COUNT + 1).

---

Example of issue:

    #[aztec(public)]
    fn two_logs() {
        context.emit_unencrypted_log(1);
        context.emit_unencrypted_log(2);
    }

    #[aztec(public)]
    fn set_value_with_nested_calls() {
        ThisContract::at(context.this_address()).two_logs().call(&mut context);
        context.emit_unencrypted_log(20);
    }

Calling set_value_with_nested_calls results in the side effects representing the log of value 2 and 20 having the same counter. Logs in the incorrect order in the kernel circuits will give an incorrect logs hash.