How to create "Gravity Roads" in a FPS?

You're correct about the CharacterController. It's the one "special" collider in Unity, that doesn't allow rotation, you will need an ordinary capsule collider to mimic that, OR, you fake it by making the CharacterController round by setting it's hight to 0 (or nearly zero, not sure what happens with 0) and only rotate the visual according to surface normal. Using a rigidbody you'd definitely have a lot more work first. I'd also avoid jumping and implement following surfaces first.

Thanks for helping, @Hexagonius. At this point I might as well share my new code. it's probably full of rookie mistakes I might learn how to correct. I copied a few extracts from the original FPS controller and tried to go from there.

 using System;
 using UnityEngine;
 using UnityStandardAssets.CrossPlatformInput;
 using UnityStandardAssets.Utility;
 using Random = UnityEngine.Random;
 
 namespace Assets.Scripts
 {
 
     public class FPS_Control : MonoBehaviour
     {
         [SerializeField] private bool m_IsWalking;
         [SerializeField] private float m_WalkSpeed;
         [SerializeField] private float m_RunSpeed;
         [SerializeField] private float m_StickToGroundForce;
         [SerializeField] private bool m_UseFovKick;
         [SerializeField] private FOVKick m_FovKick = new FOVKick();
         [SerializeField] private float m_GravityMultiplier;
 
         private Camera m_Camera;
         private bool m_Jump;
         private float m_YRotation;
         private Vector2 m_Input;
         private Vector3 m_MoveDir = Vector3.zero;
         private CollisionFlags m_CollisionFlags;
 
         private bool isGrounded = false;
 
         private Transform m_PhysicalBody;
         private Rigidbody m_PhysicalBody_rigidBody;
         private SphereCollider m_PhysicalBody_hitbox;
 
         Vector3 currentGravity;
         bool isOnGravRoad = false;
 
         // Use this for initialization
         private void Start()
         {
             m_PhysicalBody = transform.Find("TestPlayer_Sphere");
             m_PhysicalBody_rigidBody = m_PhysicalBody.GetComponent<Rigidbody>();
             m_PhysicalBody_hitbox = m_PhysicalBody.GetComponent<SphereCollider>();
             currentGravity = Physics.gravity;
         }
 
         private void FixedUpdate()
         {
             m_PhysicalBody_rigidBody.WakeUp();
 
             float speed;
             GetInput(out speed);
             // always move along the camera forward as it is the direction that it being aimed at
             Vector3 desiredMove = transform.forward * m_Input.y + transform.right * m_Input.x;
 
             // get a normal for the surface that is being touched to move along it
             RaycastHit hitInfo;
             Physics.SphereCast(m_PhysicalBody.position, m_PhysicalBody_hitbox.radius, currentGravity.normalized, out hitInfo,
                                (m_PhysicalBody_hitbox.radius+2f) / 2f);
 
             desiredMove = Vector3.ProjectOnPlane(desiredMove, hitInfo.normal).normalized;
 
             Debug.DrawLine(m_PhysicalBody.position + Vector3.zero, m_PhysicalBody.position + desiredMove * 20, Color.green, 1f, false);
 
             // attempt to change the gravity depending on surface
             if (hitInfo.collider != null)
             {
                 if (hitInfo.collider.tag == "GravityRoad")
                 {
                     isOnGravRoad = true;
                     if (hitInfo.normal.normalized != -currentGravity.normalized)
                     {
                         currentGravity = -(hitInfo.normal.normalized) * 9.81f;
                         Physics.gravity = currentGravity;
                     }
 
                 }
                 else
                 {
                     isOnGravRoad = false;
                 }
             }
 
             //Debug.Log(hitInfo.normal);
             Debug.DrawLine(m_PhysicalBody.position + Vector3.zero, m_PhysicalBody.position + hitInfo.normal*20, Color.red, 1f, false);
 
             m_MoveDir.x = desiredMove.x * speed;
             m_MoveDir.z = desiredMove.z * speed;
 
             if (isGrounded)
             {
                 m_MoveDir.y = -m_StickToGroundForce;
             }
             else
             {
                 m_MoveDir += Physics.gravity * m_GravityMultiplier * Time.fixedDeltaTime;
             }
             m_PhysicalBody_rigidBody.MovePosition(m_PhysicalBody_rigidBody.position + m_MoveDir);
 
             UpdateCameraPosition(speed);
         }
 
         private void GetInput(out float speed)
         {
             // Read input
             float horizontal = CrossPlatformInputManager.GetAxis("Horizontal");
             float vertical = CrossPlatformInputManager.GetAxis("Vertical");
 
             bool waswalking = m_IsWalking;
 
             // On standalone builds, walk/run speed is modified by a key press.
             // keep track of whether or not the character is walking or running
             m_IsWalking = !Input.GetKey(KeyCode.LeftShift);
 
             // set the desired speed to be walking or running
             speed = m_IsWalking ? m_WalkSpeed : m_RunSpeed;
             m_Input = new Vector2(horizontal, vertical);
 
             // normalize input if it exceeds 1 in combined length:
             if (m_Input.sqrMagnitude > 1)
             {
                 m_Input.Normalize();
             }
 
             // handle speed change to give an fov kick
             // only if the player is going to a run, is running and the fovkick is to be used
             if (m_IsWalking != waswalking && m_UseFovKick && m_PhysicalBody_rigidBody.velocity.sqrMagnitude > 0)
             {
                 StopAllCoroutines();
                 StartCoroutine(!m_IsWalking ? m_FovKick.FOVKickUp() : m_FovKick.FOVKickDown());
             }
         }
 
     }
 }

what value is your debug red line based of? If it's the normal from the collision object, that's always the direction the collision came in from. usually you need to raycast against the collider in that spot to get the actual surface normal