EDIT: I've solved the problem! Here's the link to the post since I can't seem to select my own response as "Best answer".

Original:
I've been searching for days trying to find an answer and unfortunately, no dice just yet.

I am using Godot 3.5.2 LTS. My player is a KinematicBody, and I'm animating other KinematicBody nodes to act as moving platforms, while others are rotating platforms.

My player follows the motion of the platforms just fine, but will stay facing the same direction they landed on the rotating platform. For example, let's say they landed on the rotating platform facing north. They will ALWAYS face north, even though they should naturally start to rotate with the rotating platform.

Part of my issue is that I suppose I was assuming that KinematicBodies would also be able to inherit rotational velocities from other KinematicBody nodes, but I suppose this must not be true? I could swear I saw some mention of it being able to do that quite some time ago, but I cannot find it anywhere.

So what does one have to do to achieve this? Again, I'm coming up completely dry on my searches. I did have the terrible idea of re-parenting my player to the platforms, but that has many, many issues and is more of a headache than it is worth, plus goes against the entire design language of the engine!

I did something like this in my game Hikikomori with some "planets" that would catch players in an orbit and then allow them to jump off.

The way I did it is I attached an Area2D around the sphere and had it rotate. I used an empty variable as a "container" for the player that would recognize them when entering and "release" them when the container was null. Then, when the player was "captured" in said "container," they would rotate along with the platform. I didn't do sprite rotation but I am sure you can figure that out. Generally it's good to handle animation and physics separately, I find. Just make sure you reset the player's rotation to default once they exit the Area or you'll have more shenanigans.

Essentially, I connected a signal to the Area to populate the container variable with the player once they were in the Area, and release them after jumping out. It's not perfect but it's workable.

var _target = null ## holder for player
var _catchFlag = false ## prevents retrigger on exit
export var _exitVelocity : int = 20 ## speed of player exit jump (might not want to edit in yours)
export var _orbitDivision : int = 1 ## gravity divide down modulator in editor (rotation speed modulation)
export var _parentBehavior : bool = false

func _physics_process(_delta):
	$GravityArea/CollisionShape2D.global_position = self.global_position ## protect global positions
	rotate(0.1/_orbitDivision) ## rotate node every frame and divide rotation by var
	_escapeOrbit() ## listen for "escape" velocity, here's where you'd put an "escape" command and reset default values
	
	
	if _parentBehavior and get_parent().visible == true:
		if _target != null: ## when player caught, they are "hovering" in gravity "mitt"
			_target.global_position = $CatchZone/CollisionShape2D.global_position
			### and you can modify player behavior here as well, i had custom stuff here you'll want to change anyway
	else:
		pass

	if !_parentBehavior and _target != null: ## when player caught, they are "hovering" in gravity "mitt"
		_target.global_position = $CatchZone/CollisionShape2D.global_position
		_target._moveState = 2 ## falling animation


func _on_GravityArea_body_entered(body): ## "catch" player and rotate them
	if body.name == "Player" and _catchFlag == false:
		_catchFlag = true ## catch flag flips, allowing escape on input
		$CatchZone/CollisionShape2D.global_position = body.global_position ## body moves with node
		_target = body ## player captured


func _on_CatchZone_body_exited(body):## reset flag after player escape
	if body.name == "Player":
		_catchFlag = false


func _escapeOrbit(): ## listen for inputs to cancel gravity pull, this is mine but you'll probably want something different
### note that the inputs "release" the player to stop them from rotating, reset defaults here as well
	if _target != null:
		if Input.is_action_just_pressed("ui_up"):
			_target._collision_on()
			_target._velocity.y-=(_exitVelocity*3)
			_target.rotation_degrees = 0
			_target = null
		elif Input.is_action_just_pressed("ui_down"):
			_target._collision_on()
			_target._velocity.y+=(_exitVelocity*3)
			_target.rotation_degrees = 0
			_target = null
		elif Input.is_action_just_pressed("ui_left"):
			_target._collision_on()
			_target._velocity.x-=(_exitVelocity*3)
			_target.rotation_degrees = 0
			_target = null
		elif Input.is_action_just_pressed("ui_right"):
			_target._collision_on()
			_target._velocity.x+=(_exitVelocity*3)
			_target.rotation_degrees = 0
			_target = null

    SnapCracklins I tried something along that idea, where if the player entered an Area on the platform, the platform would add its rotation to the player's rotation. However, this resulted in my character controller spinning wildly as though it were at a retro disco night, so either I'm calculating the rotation wrong (very likely), or there is something fundamentally wrong with the way I implemented it (extremely likely).

    The fact that I cannot find ANYTHING on this is bizarre. Surely I'm not the first person wanting to do this? Is this just not possible with a Kinematicbody and do I need to use a rigidbody?

      After many hours that resulted in only a few actual minutes of work (I have kids so distractions are easy, haha!), I finally found a solution!

      I attached an area to my rotating platform, and connected two signals with the following code in an attached script:

      # If the player walks/lands on the platform
func _on_Platform_body_entered(body):
	if body.is_in_group("player"):
		# Store the platform node for the player
		body._platform = get_node(".")
		
		# Cache the last rotation minus the rotation of the platform
		body._last_rotation = body.rotation.y - rotation.y
		
		# The player is on a rotating platform
		body._on_platform = true


func _on_Platform_body_exited(body):
	if body.is_in_group("player"):
		# Player is no longer on a rotating platform
		body._on_platform = false
		
		# Must make sure the player doesn't remember this!
		body._platform = null

      Then, in my player script, I just do the following when it comes time to figure out rotation:

      # Apply rotation by calculating the look direction
if Vector2(_velocity.z, _velocity.x).length() > 0:
	var look_direction = Vector2(_velocity.z, _velocity.x) * -1
	rotation.y = lerp_angle(rotation.y, look_direction.angle(), delta * 25)
		
	# If we're moving on a rotating platform, subtract its rotation from our own
	if _on_platform and is_on_floor():
		rotation.y = rotation.y - _platform.rotation.y
			
	# Cache the last rotation we applied during movement
	_last_rotation = rotation.y

# If we're standing still on a rotating platform, rotate us and add the last rotation
# calculated during movement
if _on_platform and is_on_floor():
	rotation.y = _last_rotation + _platform.rotation.y

      And it all works beautifully now!