Hello again,
After digesting the tip from @alexandresablayrolle about multiple backward passes, I think I now have localized the root cause of the problem. Not hard to find after that tip tbh.
Nevertheless, i was a little confused, because it indicated a problem with the unmodified model aswell. But training the unmodified model works just fine.
The problem is the gradient penalty, which is added to the loss function of the discriminator.
The penalty is added to enforce a soft 1-Lipschitz constraint on the gradient norms to stabilize convergence with the Wasserstein Distance. Meaning, the model is regularized to have gradient norms of 1.  The other way of enforcing a 1-Lipschitz constraint is to clip the gradient norms at 1.
Usually the gradient penalty is preferred, because it performs much better.
However, as you know for DP we have to clip the gradient norms anyway 
So the easiest fix for the problem is just removing  pen.backward(retain_graph=True)  and set max_grad_norm = 1 and we should be fine except the potential heavy loss in utility.
However, I am wondering if gradient penalty still makes sense in this situation and set max_grad_norm>1, e,g: 2, and let the model enforce grad norms of 1 itself.
The reason, i feel uncomfortable removing all the features of CT-GAN. But if that is the price for privacy i guess we have to pay it.
                    #pen = discriminator.calc_gradient_penalty(
                        #real_cat, fake_cat, self._device, self.pac)
                    loss_d = -(torch.mean(y_real) - torch.mean(y_fake))
                    
                    optimizerD.zero_grad()
                    #pen.backward(retain_graph=True)
                    loss_d.backward()
                    optimizerD.step()

In addition to that, as far as i understood using retrain_graph=True should be the same as
                    loss_d = -(torch.mean(y_real) - torch.mean(y_fake)) + pen 
                    optimizerD.zero_grad()
                    loss_d.backward()
                    optimizerD.step()

But this also produces the same error and i dont understand why.
If the regularization is truly the problem my intuition tells me that this should be supported. However, maybe this is intended such that silly constraints are note enforced.
PS: after finding this i reviewed the code of smartnoise-sdk (second link) again and i found they also removed gradient penalty. But i missed it. Also they do not mention it in their paper.