Perform hybrid computations in parallel

Required prerequisites

• Search the issue tracker to check if your feature has already been mentioned or rejected in other issues.

Describe the feature

A simple hybrid algorithm to minimize a cost function looks something like this in CUDAQ:

import cudaq 
from cudaq import spin 
import numpy as np 

kernel, params = cudaq.make_kernel(list)
qubits = kernel.qalloc(1)
kernel.rx(params[0], qubits[0])

hamiltonian = spin.z(0)
  
    
def cost(parameters):
    return cudaq.observe(kernel, hamiltonian, parameters).expectation()

optimizer = cudaq.optimizers.COBYLA()
optimizer.initial_parameters = np.random.uniform(0,1, 1)   
optimizer.max_iterations = 50

result = optimizer.optimize(dimensions = 1, function=cost)

The minimization procedure runs the observe call in tandem with classical processing.

I would like to execute multiple minimization procedures in parallel. The observe call could be replaced with observe_async however the classical processing done by COBYLA will require one to set up a multiprocessing loop spawning multiple threads to achieve this.

We would like users to not have to manually set up the multiprocessing loop but rather have a minimize_async functionality. This would be similar in scope to the vqe functionality we have but one where we can minimize different kernels and hamiltonians in parallel.

cc @mmvandieren

Start with the Python optimization example in the issue and review the existing vqe functionality as the closest reference point. Define how a minimize_async API should run multiple kernel and Hamiltonian minimizations in parallel without user-managed multiprocessing, then add coverage for the supported behavior.