### Godot version

v4.0.beta14.official [28a24639c] (But also present in master)

### System information

Irrelevant

### Issue description

`Transform2D::interpolate_with` works by breaking two `Transform2D`s into rotation, scale, and translation, interpolating the two, then rebuilding a new `Transform2D` from the interpolated values. However, the rebuild is wrong. This is the offending code:
```
	Transform2D res(v.angle(), p1.lerp(p2, p_c));
	res.scale_basis(s1.lerp(s2, p_c));
```

The transform is first created with a rotation, then scaled. However, the scale is done along the axes, not along the rotated vectors. If the scale is uniform, this doesn't matter. If it's non-uniform, this can actually introduce a skew into the result, which is pretty bad, considering the function actually discards skew.

The correct order should be backwards - First scale, then rotation. Alternately, replace the axis-aligned scale with a scale of the vectors themselves. Or add a function to build a matrix from rotation, scale, skew, and transform, using the formula

```
mat.x = scale.x*Vector2(cos(rotation), sin(rotation))
mat.y = scale.y*Vector2(cos(rotation+skew+PI*0.5), sin(rotation+skew+PI*0.5))
mat.origin = translation
```

The bigger issue is that it has an effect even if `p_c` is `1.0`, making classes that use it internally like `Skeleton2D` introduce bugs in code that should be fairly safe.

A possible workaround is to add special cases for `p_c==0.0` and `p_c==1.0`, as going through all the math, and introducing numerical instability and information loss in the middle, is pointless for those cases.

### Steps to reproduce

```
			var source = Transform2D.IDENTITY
			source = source.scaled(Vector2(1, 2))
			source = source.rotated(0.25*PI)
			print(source)
			print(source.get_scale())
			print(source.get_rotation())
			print(source.get_origin())
			print(source.get_skew())
			var interpolated = Transform2D.IDENTITY.interpolate_with(source, 1.0)
			print(interpolated)
			print(interpolated.get_scale())
			print(interpolated.get_rotation())
			print(interpolated.get_origin())
			print(interpolated.get_skew())
```
The interpolation value is `1.0` and `source.get_skew()` returns 0, yet `interpolated.get_skew()` returns `-0.64350110292435`, even the the interpolation is supposed to erase skew, not create it.

### Minimal reproduction project

N/A
#ifndef TEST_TRANSFORM_2D_H
#define TEST_TRANSFORM_2D_H
#include "core/math/transform_2d.h"
#include "tests/test_macros.h"
namespace TestTransform2D {
Transform2D create_dummy_transform() {
	return Transform2D(Vector2(1, 2), Vector2(3, 4), Vector2(5, 6));
}
Transform2D identity() {
	return Transform2D();
}
TEST_CASE("[Transform2D] translation") {