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

#ifdef DEBUG_ENABLED
	ERR_FAIL_COND(p_point_count_A < 3);
	ERR_FAIL_COND(p_point_count_B != 3);
#endif
	const Vector3 &circle_B_pos = p_points_B[0];
	Vector3 circle_B_line_1 = p_points_B[1] - circle_B_pos;
	Vector3 circle_B_line_2 = p_points_B[2] - circle_B_pos;
	
	static const int circle_segments = 8;
	Vector3 circle_points[circle_segments];
	real_t angle_delta = 2.0 * Math_PI / circle_segments;
	for (int i = 0; i < circle_segments; ++i) {
		Vector3 point_pos = circle_B_pos;
		point_pos += circle_B_line_1 * Math::cos(i * angle_delta);
		point_pos += circle_B_line_2 * Math::sin(i * angle_delta);
		circle_points[i] = point_pos;
	}
	_generate_contacts_face_face(p_points_A, p_point_count_A, circle_points, circle_segments, p_callback);
	
	Vector3 circle_B_normal = circle_B_line_1.cross(circle_B_line_2).normalized();
	Plane circle_plane(circle_B_normal, circle_B_pos);
	static const int max_clip = 32;
	Vector3 contact_points[max_clip];
	int num_points = 0;
	for (int i = 0; i < p_point_count_A; i++) {
		int i_n = (i + 1) % p_point_count_A;
		const Vector3 &edge0_A = p_points_A[i];
		const Vector3 &edge1_A = p_points_A[i_n];
		real_t dist0 = circle_plane.distance_to(edge0_A);
		real_t dist1 = circle_plane.distance_to(edge1_A);