Fix method caching bug when including/prepend module A that prepends module B

	Fix by always adding the generated iclass to the subclasses list,
	otherwise the method cache for the iclass is not cleared when
	the method in the module is overwritten.

	Fixes [Bug #20716]

Fix incorrect use of VM_CALL_KW_SPLAT_MUT in zsuper with keyword splat

	For zsuper calls with a keyword splat but no actual keywords, the
	keyword splat is passed directly, so it cannot be mutable, because
	if the callee accepts a keyword splat, changes to the keyword splat
	by the callee would be reflected in the caller.

	While here, simplify the logic when the method supports
	literal keywords.  I don't think it is possible for
	a method with has_kw param flags to not have keywords, so add an
	assertion for that, and set VM_CALL_KW_SPLAT_MUT in a single place.

Tests for GitHub PR #5122. Originally in GitHub PR #5121.

The cme is NULL when a method does not exist, so check it before
accessing the callcache.

The same bug as 8355a99883 existed in attr_reader too.

We started to use fastpath on invokesuper when a method is not refinements
since 5c27681813, but we shouldn't have used fastpath for attr_writer either.

`cc->aux_.attr_index` is for an actual receiver class, while we store
its superclass in `cc->klass` and therefore there's no way to properly
invalidate attr_writer's inline cache when it's called by super.

[Bug #16785]

I suspect the same bug also exists in attr_reader. I'll address that in
another commit.

me->called_id and me->def->original_id can be different sometimes
so we should compare with called_id, which is mtbl's key.
(fix GH-PR #2869)

This makes behavior the same as super in instance_eval in method
in class.  The reason this wasn't implemented before is that
there is a check to determine if the self in the current context
is of the expected class, and a module itself can be included
in multiple classes, so it doesn't have an expected class.

Implementing this requires giving iclasses knowledge of which
class created them, so that super call in the module method
knows the expected class for super calls.  This reference
is called includer, and should only be set for iclasses.

Note that the approach Ruby uses in this check is not robust. If
you instance_eval another object of the same class and call super,
instead of an TypeError, you get super called with the
instance_eval receiver instead of the method receiver.  Truly
fixing super would require keeping a reference to the super object
(method receiver) in each frame where scope has changed, and using
that instead of current self when calling super.

Fixes [Bug #11636]