### Godot version

4.0 beta 10

### System information

Windows 10, NVidia 2070, Vulkan Mobile

### Issue description

A human-sized (0.4 x 1.8 x 0.4) CapsuleShape3D on top of a large (50 x 50 x 50) SphereShape3D produces unstable normals when performing a move_and_collide down.

In discussions on the physics channel of the Godot Contributors Chat, the SAT solver isn't a good choice when the exact collision information can be solved analytically.

The problem with the SAT solver is that it ends up producing two collision points A and B on the two colliding shapes, and then the vector between them is used to build the normal. The problem is that A and B end up being extremely close (1e-4 distance), so normalizing the vector results in a large amplification of any numeric errors.

The current API for the ```_collision_<shape1>_<shape2>()``` functions can only report their findings via the ```_CollectorCallback``` API, and that only allows for providing the A and B points. Instead the collision functions should also have a means of providing exact analytic collision information if available.

### Steps to reproduce

Construct a scene consisting of a large 50m sphere with a capsule shape resting on top of it. Then perform a move_and_collide down and print the collision normal vector. 

### Minimal reproduction project

[SphereCapsuleCollision.zip](https://github.com/godotengine/godot/files/10306031/SphereCapsuleCollision.zip)

This demo walks a capsule around the top of a large sphere drawing the normal vector. The vector flickers between the correct normal and weird unstable normals:
![image](https://user-images.githubusercontent.com/1863707/209614550-5d631bb3-de05-463b-baf7-3c51b00b36e4.png)

_CollectorCallback callback;
	callback.callback = p_result_callback;
	callback.swap = p_swap;
	callback.userdata = p_userdata;
	callback.collided = false;
	callback.prev_axis = r_prev_axis;
	const GodotShape3D *A = p_shape_A;
	const GodotShape3D *B = p_shape_B;
	const Transform3D *transform_A = &p_transform_A;
	const Transform3D *transform_B = &p_transform_B;
	real_t margin_A = p_margin_a;
	real_t margin_B = p_margin_b;
	if (type_A > type_B) {
		SWAP(A, B);
		SWAP(transform_A, transform_B);
		SWAP(type_A, type_B);
		SWAP(margin_A, margin_B);
		callback.swap = !callback.swap;
	}
	CollisionFunc collision_func;
	if (margin_A != 0.0 || margin_B != 0.0) {
		collision_func = collision_table_margin[type_A - 2][type_B - 2];
	} else {
		collision_func = collision_table[type_A - 2][type_B - 2];
	}
	ERR_FAIL_COND_V(!collision_func, false);
	collision_func(A, *transform_A, B, *transform_B, &callback, margin_A, margin_B);
	return callback.collided;
}