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

if (dist_sq <= circle_B_radius * circle_B_radius) {
		contact_points[num_points] = edge_A_1;
		++num_points;
	}
	const Vector3 &edge_A_2 = p_points_A[1];
	Vector3 proj_point_2 = circle_plane.project(edge_A_2);
	Vector3 dist_vec_2 = proj_point_2 - circle_B_pos;
	real_t dist_sq_2 = dist_vec_2.length_squared();
	
	if (dist_sq_2 <= circle_B_radius * circle_B_radius) {
		contact_points[num_points] = edge_A_2;
		++num_points;
	}
	if (num_points < 2) {
		Vector3 line_vec = proj_point_2 - proj_point_1;
		real_t line_length_sq = line_vec.length_squared();
		
		real_t a, b, c;
		a = line_length_sq;
		b = 2.0 * dist_vec.dot(line_vec);
		c = dist_sq - circle_B_radius * circle_B_radius;
		
		real_t sqrtterm = b * b - 4.0 * a * c;
		
		
		if (sqrtterm >= 0) {
			sqrtterm = Math::sqrt(sqrtterm);
			Vector3 edge_dir = edge_A_2 - edge_A_1;
			real_t fraction_1 = (-b - sqrtterm) / (2.0 * a);
			if ((fraction_1 > 0.0) && (fraction_1 < 1.0)) {