Ruby: Synthesize implicit super arguments

[hvitved]

Inspired by #19164, this PR synthesizes implicit super arguments. For example, in

class Sup
  def m(x, *rest, k:, **kwargs)
    print(x + 1)
    print(k + 1)
  end
end

class Sub < Sup
  def m(y, *rest, k:, **kwargs)
    super
  end
end

we synthesize arguments in the call to super so that it actually becomes super(y, *rest, k: k, **kwargs). We additionally also synthesize an implicit block argument, but that only pertains to data flow.

The benefit of doing it in the AST synthesis layer is that all logic that builds on top (like control flow, SSA, data flow) automatically benefits.

DCA for the default suite shows that we gain a few new results (as expected), and DCA for a custom suite shows that we remove FPs for rb/unused-parameter and rb/useless-assignment-to-local (also as expected).

[yoff]

This looks plausible to me, but there are many changed files, so let me try to summarize my understanding and we can move forward if it is adequate:

• We wish to synthesize arguments for super calls, these can take a variety of forms including symbols, pairs and splat arguments.
• Some of these forms, we do not yet synthesize, so they are granted a new base class, FormImpl with a FormReal and a FormSynth extension. Each of these get their own branch.
• In a number of places referencing Form, we now have to choose either the real, the synthesized or both (a few places simply exclude the synth)
• TSynthKind has been given a real class
• The actual synthesis is happening in ImplicitSuperArgsSynthesis together with the new ImplicitSuperBlockArgumentNode
• Also, the position is now tracked for parameter assignments. I am not sure if this is needed for the semantics or if it is just an optimisation.