Orient vehicle to ground normal (terrain hugging)

I had the same problem: assigning transform.up seems to be equivalent to transform.rotation = Quaternion.FromToRotation(Vector3.up, newNormal). The solution for me was to keep a "compass" variable which showed the current rotation angle from forward: thus I "rotated" this angle and applied to the object using Euler:

float curDir = 0f; // compass indicating direction
float vertSpeed = 0f; // vertical speed (see note)
...
void Update(){
    float turn = Input.GetAxis("Horizontal") * turnSpeed * 100 * Time.deltaTime,
    curDir = (curDir + turn) % 360; // rotate angle modulo 360 according to input
    if (Physics.Raycast(transform.position, -transform.up, out hit))
    {
        Quaternion grndTilt = Quaternion.FromToRotation(transform.up, hit.normal);
        transform.rotation = grndTilt * Quaternion.Euler(0, curDir, 0);
    }
    Vector3 movDir;
    movDir = transform.forward*Input.GetAxis("Vertical")*speed;
    // moves the character in horizontal direction (gravity changed!)
    if (controller.isGrounded) vertSpeed = 0; // zero v speed when grounded
    vertSpeed -= 9.8f * Time.deltaTime; // apply gravity
    movDir.y = vertSpeed; // keep the current vert speed
    controller.Move(movDir*Time.deltaTime);
    ...

An alternative way to do that is using the OnControllerColliderHit event to get the normal - but only if its Y coordinate is > 0.3 (or some other suitable value) or else the car can stick to walls or to other vehicles during lateral collisions!
NOTE: I changed the way gravity is applied - it gives a better behaviour when "flying" after a hill. Discard these changes if you don't want them - the rotation thing is at the beginning, and has nothing to do with gravity.

EDITED: There was an error in the script above: the rotation was being calculated from transform.up to the normal (it should be Vector3.up to normal) what was causing the crazy instability.
In my tests, I also noticed that the vehicle was following the terrain normal immediately, what was producing a strange behaviour. I added a new variable - curNormal - which smoothly followed the terrain normal using Lerp, and also was used in the Raycast to avoid other instabilities. The result is very convincent - hope you like it too:

 float curDir = 0f; // compass indicating direction
 float vertSpeed = 0f; // vertical speed (see note)
 Vector3 curNormal = Vector3.up; // smoothed terrain normal
 
 void Update(){
     float turn = Input.GetAxis("Horizontal") * turnSpeed * 100 * Time.deltaTime;
     curDir = (curDir + turn) % 360; // rotate angle modulo 360 according to input
     RaycastHit hit;
     if (Physics.Raycast(transform.position, -curNormal, out hit)){
         curNormal = Vector3.Lerp(curNormal, hit.normal, 4*Time.deltaTime);
         Quaternion grndTilt = Quaternion.FromToRotation(Vector3.up, curNormal);
         transform.rotation = grndTilt * Quaternion.Euler(0, curDir, 0);
     }
     Vector3 movDir;
     movDir = transform.forward*Input.GetAxis("Vertical")*speed;
     // moves the character in horizontal direction (gravity changed!)
     if (controller.isGrounded) vertSpeed = 0; // zero v speed when grounded
     vertSpeed -= 9.8f * Time.deltaTime; // apply gravity
     movDir.y = vertSpeed; // keep the current vert speed
     controller.Move(movDir*Time.deltaTime);
 }

JAVASCRIPT VERSION:

 private var curDir: float = 0f; // compass indicating direction
 private var vertSpeed: float = 0f; // vertical speed (see note)
 private var curNormal = Vector3.up; // smoothed terrain normal
 
 function Update(){
     var turn = Input.GetAxis("Horizontal") * turnSpeed * 100 * Time.deltaTime;
     curDir = (curDir + turn) % 360; // rotate angle modulo 360 according to input
     var hit: RaycastHit;
     if (Physics.Raycast(transform.position, -curNormal, hit)){
         curNormal = Vector3.Lerp(curNormal, hit.normal, 4*Time.deltaTime);
         var grndTilt = Quaternion.FromToRotation(Vector3.up, curNormal);
         transform.rotation = grndTilt * Quaternion.Euler(0, curDir, 0);
     }
     var movDir = transform.forward*Input.GetAxis("Vertical")*speed;
     // moves the character in horizontal direction (gravity changed!)
     if (controller.isGrounded) vertSpeed = 0; // zero v speed when grounded
     vertSpeed -= 9.8f * Time.deltaTime; // apply gravity
     movDir.y = vertSpeed; // keep the current vert speed
     controller.Move(movDir*Time.deltaTime);
 }

 if (Physics.Raycast(transform.position + transform.forward * front, -transform.up, out hitA))
 {
     RaycastHit hitB;
     if (Physics.Raycast(transform.position - transform.forward * back, -transform.up, out hitB))
         transform.forward = hitA.point - hitB.point; // check A to B vector and align forward

This topic seems like it comes up at least once a day :P

Here's my take on it, a few links and some quick code.

1. make-player-character-stick-to-the-level-mesh 2. walking-on-a-cube 3. How-in-the-world-were-the-physics-in-F-zero-X-done 4. script-for-hovercraft-mechanics

I like to keep things simple. So if you can get away with the least amount of code, do it.. Use a SphereCast with a radius appropriate for your vehicle/player. One SphereCast with a Lerp will give you the feel of using 4 or more raycast without the complexity. If you don't want to climb 90° angles make the radius less than half the vehicle/player width. If you want free rotation physics while in the air use a small distance for the SphereCast. Example code below uses 0.5 meter radius and 5 meter distance.

 RaycastHit hit;
 if (Physics.SphereCast(transform.position, 0.5f, -transform.up, out hit, 5)) {
     transform.rotation = Quaternion.Lerp(transform.rotation, Quaternion.LookRotation(Vector3.Cross(transform.right, hit.normal), hit.normal), Time.deltaTime * 5.0f);
 }

If you want more precision SphereCast or Raycast either at points spread out then cast down or from the center cast at 45° angles down and out then average the angles to get the best orientation.

For the rotation, it snaps back because your code says the rotation is the current value of the arrow keys. Of course when you let go it snaps to 0. Use the arrows to add to rotation (the answer above.)

For raycast wiggling, use -Vector3.up as the aim dir instead of -transform.up. The latter is down from our tilt. So, tilting changes the raycast dir, which hits the ground somewhere else, which gets a diff normal, which makes you tilt a different dir... . You'll wiggle any time you stand still on a curved surface. The effect is worse as your (0,0,0) gets further off the ground. -Vector3.up is always straight down, which won't change as we tilt.

Setting transform.up wants to override any previous tilt you have. It's actually doing a bit of math to figure out how to get up to point that way. Using *grndTilt (if it stands for the tilt from "no change" to "ground normal" changes your up while keeping everything the same.

To apply the grndTilt, the order multiplying quaternions matters, and it's usually backwards to how you think. Try flipping *grndtilt to in front instead of in back (that's in the answer above, but is easy to miss, since we are so used to thinking a*b and b*a are the same.) Or, you can think of doing the tilt as: transform.rotation = tilt*transform.rotation;

Aldonaletto's answer worked for me like this:

     public GameObject target;
     float curDir = 0f; // compass indicating direction
     Vector3 curNormal = Vector3.up; // smoothed terrain normal
     public float turn;    
 
     // Update is called once per frame
     void Update () 
     {
                 
         curDir = (curDir + turn) % 360; // rotate angle modulo 360 according to input
         RaycastHit hit;
         if (Physics.Raycast(target.transform.position, -curNormal, out hit))
         {
             curNormal = Vector3.Lerp(curNormal, hit.normal, 4*Time.deltaTime);
             Quaternion grndTilt = Quaternion.FromToRotation(Vector3.up, curNormal);
             target.transform.rotation = grndTilt * Quaternion.Euler(0, curDir, 0);
         }
     }

If you want the object to turn just set turn to .01f or whatever amount until it has turned as much as you need then set it back to 0.