Improvements to Constraint Solvers SIMD(btSequentialImpulseConstraintSolver.cpp)

[TrianglesPCT]

I made some local improvements to the SIMD constraint solver kernals, but my bullet has been modified so much it doesn't match with github anymore(among other things I replaced most of the manual SIMD code with my own library that wraps SSE/AVX)

So I am just going to show to places where improvements can be made to the solvers..

1. The upper and lower limit can be applied with much less code
The way the clamping is being done is not very efficient, and generates a bunch of unnecessary instructions..
Current Bullet code:

tmp = _mm_add_ps(c.m_appliedImpulse, deltaImpulse);  // sum
	const __m128 maskLower = _mm_cmpgt_ps(tmp, lowerLimit);
	const __m128 maskUpper = _mm_cmpgt_ps(upperLimit, tmp);
	deltaImpulse = _mm_blendv_ps(_mm_sub_ps(lowerLimit, c.m_appliedImpulse), _mm_blendv_ps(_mm_sub_ps(upperLimit, c.m_appliedImpulse), deltaImpulse, maskUpper), maskLower);
	c.m_appliedImpulse = _mm_blendv_ps(lowerLimit, _mm_blendv_ps(upperLimit, tmp, maskUpper), maskLower);

Improved version with same result(~9 instructions vs ~4 instructions)
I merged the Generic/LowerLimit version into a single function with compile time constant, as the only difference is this single min()

        math::v4float  sum = deltaImpulse + impulse;
	math::v4float clampedSum = max(sum, math::v4float(c.m_lowerLimit));
	if constexpr (HasHigherLimit) 
		clampedSum = min(clampedSum, math::v4float(c.m_upperLimit));
	}
	c.m_appliedImpulse = clampedSum;
	deltaImpulse = clampedSum - impulse;

2. The giant dot product is very inefficient, it uses multiple horizontal operations when only 1 is needed. It also suffers from many rounding events because of this(reducing precision). ( _mm_dp_ps rounds has a rounding event after each internal op)

	const __m128 deltaVel1Dotn = _mm_add_ps(DOT_PRODUCT(c.m_contactNormal1.mVec128, bodyA.internalGetDeltaLinearVelocity().mVec128), DOT_PRODUCT(c.m_relpos1CrossNormal.mVec128, bodyA.internalGetDeltaAngularVelocity().mVec128));
	const __m128 deltaVel2Dotn = _mm_add_ps(DOT_PRODUCT(c.m_contactNormal2.mVec128, bodyB.internalGetDeltaLinearVelocity().mVec128), DOT_PRODUCT(c.m_relpos2CrossNormal.mVec128, bodyB.internalGetDeltaAngularVelocity().mVec128));
	deltaImpulse = FMNADD(deltaVel1Dotn, tmp, deltaImpulse);
       deltaImpulse = FMNADD(deltaVel2Dotn, tmp, deltaImpulse);

Instead do something like this, now we only have a single horizontal op at the end, and everything before is wide SIMD--the result is both faster and more accurate.

```
math::v4float  deltaV = FMADD(contactNorm1, b1Vel, FMADD(math::v4float(c.m_relpos1CrossNormal.mVec128),b1Ang,
						FMADD(contactNorm2, b2Vel,  math::v4float(c.m_relpos2CrossNormal.mVec128) * b2Ang)));

deltaImpulse = deltaImpulse - DOT_PRODUCT(deltaV, _mm_set_ps1(c.m_jacDiagABInv));

_I also wrote some AVX version of these kernels, as it turns out you can generally stick the velocity part in the lower 128 bits, and the acceleration part in the upper 128 bits._