### 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)

static const int max_clip = 32;
	Vector3 _clipbuf1[max_clip];
	Vector3 _clipbuf2[max_clip];
	Vector3 *clipbuf_src = _clipbuf1;
	Vector3 *clipbuf_dst = _clipbuf2;
	int clipbuf_len = p_point_count_A;
	
	for (int i = 0; i < p_point_count_A; i++) {
		clipbuf_src[i] = p_points_A[i];
	}
	Plane plane_B(p_points_B[0], p_points_B[1], p_points_B[2]);
	
	for (int i = 0; i < p_point_count_B; i++) {
		int i_n = (i + 1) % p_point_count_B;
		Vector3 edge0_B = p_points_B[i];
		Vector3 edge1_B = p_points_B[i_n];
		Vector3 clip_normal = (edge0_B - edge1_B).cross(plane_B.normal).normalized();
		
		Plane clip(clip_normal, edge0_B);
		
		int dst_idx = 0;
		bool edge = clipbuf_len == 2;
		for (int j = 0; j < clipbuf_len; j++) {
			int j_n = (j + 1) % clipbuf_len;
			Vector3 edge0_A = clipbuf_src[j];
			Vector3 edge1_A = clipbuf_src[j_n];
			real_t dist0 = clip.distance_to(edge0_A);
			real_t dist1 = clip.distance_to(edge1_A);
			if (dist0 <= 0) { 
				ERR_FAIL_COND(dst_idx >= max_clip);