Fix double QubitUnitary bug from Catalyst (#6926)

**Context:**
A recent deprecation #6840
deprecated the usage of `QubitUnitary` type input `base` for
instantiation of `ControlledQubitUnitary`.
However, a modification that was equivalent in PennyLane caused
unexpected behavior in Catalyst,
PennyLaneAI/catalyst#1494.
After investigation, it appears to be the issue with the private method
`_try_wrap_in_custom_ctrl_op` of `pennylane/ops/op_math/controlled.py`,
since it used to call the deprecated `init` to directly use base as
`QubitUnitary`, and to safely deprecate it we decided to locally replace
with equivalent `ControlledQubitUnitary(base=op.matrix(), ...)`, this
caused Catalyst to received double `QubitUnitary`.

It is also noteable that the call `ControlledQubitUnitary` should not
appear in this script, since logically all the classes living in
`controlled_ops` depend on `controlled.py`, which means that from the
very beginning the affected private method served as a tricky hack with
cyclic dependence.

Therefore, we would like to replace the `ControlledQubitUnitary` call
with a direct `ControlledOp`.

**Description of the Change:**
source files: as mentioned above.

tests: necessary improvements were made to correctly reflect the
assertion results.

**Benefits:**
 - Remove bugs
 - Less cyclic dependency

**Possible Drawbacks:**
- Probably there're more that depend on this method, which might be
affected by this fix

**Related GitHub Issues:**
PennyLaneAI/catalyst#1494

---------

Co-authored-by: Christina Lee <[email protected]>

Author: JerryChen97

doc/releases/changelog-dev.md

@@ -192,7 +192,9 @@
 <h3>Deprecations 👋</h3>
 
 * The ``ControlledQubitUnitary`` will stop accepting `QubitUnitary` objects as arguments as its ``base``. Instead, use ``qml.ctrl`` to construct a controlled `QubitUnitary`.
+  A folllow-on PR fixed accidental double-queuing when using `qml.ctrl` with `QubitUnitary`.
   [(#6840)](https://github.com/PennyLaneAI/pennylane/pull/6840)
+  [(#6926)](https://github.com/PennyLaneAI/pennylane/pull/6926)
 
 * The `control_wires` argument in `qml.ControlledQubitUnitary` has been deprecated.
   Instead, use the `wires` argument as the second positional argument.

pennylane/ops/op_math/controlled.py

@@ -14,6 +14,7 @@
 """
 This submodule defines the symbolic operation that indicates the control of an operator.
 """
+# pylint: disable=too-many-positional-arguments
 import functools
 import warnings
 from collections.abc import Callable, Sequence
@@ -338,6 +339,7 @@ def _try_wrap_in_custom_ctrl_op(op, control, control_values=None, work_wires=Non
         return ops_with_custom_ctrl_ops[custom_key](*op.data, control + op.wires)
 
     if isinstance(op, qml.QubitUnitary):
+        qml.QueuingManager.remove(op)
         return qml.ControlledQubitUnitary(
             op.matrix(),
             wires=control + op.wires,

tests/ops/op_math/test_controlled.py

@@ -1671,6 +1671,13 @@ def test_controlled_qaoa_embedding(self, features, weights, num_wires, batch_siz
 class TestCtrl:
     """Tests for the ctrl transform."""
 
+    def test_no_redundant_queue(self):
+        """Test that the ctrl transform does not add redundant operations to the queue. https://github.com/PennyLaneAI/pennylane/pull/6926"""
+        with qml.queuing.AnnotatedQueue() as q:
+            qml.ctrl(qml.QubitUnitary(np.eye(2), 0), 1)
+
+        assert len(q.queue) == 1
+
     def test_invalid_input_error(self):
         """Test that a ValueError is raised upon invalid inputs."""
         with pytest.raises(ValueError, match=r"<class 'int'> is not an Operator or callable."):