Noir Contract Interfaces: generate 'callable from private' and 'callable from public' interfaces

[iAmMichaelConnor]

From @LHerskind:
"The interfaces seems to have wrappers for private -> something but not from public to something. Many public functions are callable from both, but they have different return values and contexts etc."

Options seem to be:

1. Align the return values of public and private calls (but that ruins the safety of the interface, and would confuse users who'll receive useless return values when making public calls from private)
2. Create two MyContractInterface structs: MyContractInterface_CallableFromPrivate and MyContractInterface_CallableFromPublic (naming could be improved 😅). A bit ugly, but would actually make it clear that you can't make a conventional 'call' to a private function from a public function (because we'd omit private functions from the MyContractInterface_CallableFromPublic interface.
3. Create two versions of each function, within a single interface MyContractInterface, foo_from_private and foo_from_public, but that's pretty disgusting, as these names don't match the names of the original contract!

There's consensus that Option 2 is the best approach.

With option 2, the importing contract would do:

fn main(
        inputs: PrivateContextInputs,
        target: Field
    ) -> distinct pub abi::PrivateCircuitPublicInputs {
        let mut context = PrivateContext::new(inputs, abi::hash_args([target]));
        let test_contract_instance = TestContractInterface_CallableFromPrivate::at(target);
        let return_values = test_contract_instance.testCodeGen(&mut context, ...)
        // etc
}