Gradient dialect removes `qnode` attribute from quantum functions when creating helper functions.

[erick-xanadu]

• Expected behavior: The attribute remains through the lowering of gradient and quantum dialect up until LLVM-IR (in which case we might wish to annotate it with some metadata).

• Actual behavior: The gradient transforms generates helper functions which will strip the qnode attribute from qnodes. E.g.,

  func.func private @f(%arg0: tensor<f64>) -> tensor<f64> attributes {diff_method = "parameter-shift", llvm.linkage = #llvm.linkage<internal>, qnode} {
  }

Changes to:

  func.func private @f.quantum(%arg0: memref<f64>, %arg1: memref<?xf64>) -> memref<f64> attributes {gradient.qgrad = @f.qgrad, passthrough = ["noinline"]} {
}

This causes async to not be triggered since async looks for the qnode attribute.

• Reproduces how often: Always

[dime10]

Copying description from the duplicate issue:

Some MLIR transforms, like the parameter shift pass, predate the introduction of the qnode attribute on MLIR functions with quantum code. The use of the attribute has also been extended, for example to determine asynchronous execution scopes.

In order to support the asynchronous execution of shifted circuits, the parameter-shift transform should propagate the qnode attribute from the original function it acts upon to the shifted function calls which each represent an independent quantum execution.

Note I don't think the current implementation would be able to benefit much from asynchronous execution, except perhaps for two evaluations at a time, because the shifted circuits are not generated in a batched but a procedural fashion. See the following snippet, where the results a quantum call a used pretty much immediately:

catalyst/mlir/lib/Gradient/Transforms/GradMethods/PS_QuantumGradient.cpp

Lines 78 to 91 in b94be65

	// Compute the partial derivate for this parameter via the simplified
	// parameter-shift rule: df/dx = [f(x + pi/2) - f(x - pi/2)] / 2.
	callArgs.push_back(shiftVectorPos);
	callArgs.push_back(selectorVector);
	ValueRange evalPos = rewriter.create<func::CallOp>(loc, shiftedFn, callArgs).getResults();
	callArgs[callArgs.size() - 2] = shiftVectorNeg;
	ValueRange evalNeg = rewriter.create<func::CallOp>(loc, shiftedFn, callArgs).getResults();
	std::vector<Value> derivatives;
	derivatives.reserve(evalPos.size());
	for (size_t i = 0; i < evalPos.size(); i++) {
	Value diff = rewriter.create<arith::SubFOp>(loc, evalPos[i], evalNeg[i]);