✨ MLIR - Conversion from/to CUDA-Q's `quake` dialect

[burgholzer]

What's the problem this feature will solve?

Our efforts in adopting MLIR within the MQT have been steadily progressing.
#880 is the first PR that adds interoperability with an external framework, namely Xanadu's Catalyst and their Quantum dialect.
To connect the ecosystem further and to extend the compatibility of the MQT, this issue aims to add support for NVIDIA's quake dialect that is used within CUDA-Q. See https://github.com/NVIDIA/cuda-quantum/blob/main/Overview.md for a brief overview.

Describe the solution you'd like

Similarly to the solution currently being pursued in #880, it should be possible to translate MLIR programs using the Quake dialect to our internal mqtopt or mqtdyn (see comment below for more details) dialect and back.
The conversion itself can probably borrow quite a few of the implementation details from #880.
The intriguing aspect is the packaging aspect in the sense that it is still an open question how to best add these translations without adding an unconditional dependency on cuda-q. Ideally, the integration is set up similar to how we currently handle Qiskit as an optional plugin of the mqt-core Python package: https://github.com/munich-quantum-toolkit/core/tree/main/src/mqt/core/plugins/qiskit

[DRovara]

We currently have two MLIR dialects: mqtopt and mqtdyn.
mqtopt uses value semantics, i.e. each operation "consumes" a quantum state and returns an updated state.
mqtdyn uses memory semantics. Here, each operation is performed on a reference to a qubit, similar to e.g. OpenQASM's x q[0].

As Quake supports memory semantics (!quake.ref) and value semantics (!quake.wire), this makes conversions a bit more complex. We would rather not have a mix between mqtopt and mqtdyn, so the Quake operations should be converted to only one of the two dialects. I can see both of them making sense:

• Convert to mqtdyn: !quake.ref operations can be converted directly to mqtdyn qubits. For !quake.wire operations, search the reference it was originally pulled from through the quake.unwrap operation and use that information to translate the wire into a mqtdyn qubit.
• Convert to mqtopt: !quake.wire operations can be converted directly to mqtopt qubits and their corresponding quake.wrap/quake.unwrap calls roughly align with mqtopt.extractQubit and mqtopt.insertQubit calls. For !quake.ref operations, mqtopt qubits can be extracted from a register using mqtopt.extractQubit. Here, we have to keep track in detail what qubit comes from what mqtopt-register-index and from what quake.ref to make sure different operations do not interfere with each other.

Both approaches seem reasonable, but the first one (converting to mqtdyn) seems a bit simpler and may therefore be the better solution, intuitively.