Fix caching issue with always_redraw causing incorrect object placement

[SHARANcanCODE]

Description

This PR fixes issue #4160 where rendering a scene multiple times with caching enabled results in incorrect placement of objects that use always_redraw with ValueTrackers.

Problem Analysis

The issue was a variation of #550 where cached animations affected the global timestamp. When caching is used:

1. Animations are skipped to improve performance
2. However, scene.time is still incremented by the full animation duration
3. ValueTrackers and other time-dependent objects remain at their initial state
4. When always_redraw functions are evaluated, they use these incorrect initial values instead of the proper final values
5. This causes objects to appear in wrong positions on subsequent cached renders

Root Cause

In the OpenGL renderer play method, when animations were skipped due to caching, the code would bypass scene.play_internal() but still increment self.time. This left all ValueTrackers and animated mobjects in their initial state while the scene time was at the end state.

Changes Made

• Added proper final state interpolation when animations are cached and skipped
• When skip_animations is True, call scene.update_to_time(scene.duration) to ensure all animations reach their final state
• Call scene.update_mobjects(0) to update all mobjects after interpolation
• Preserves the performance benefits of caching while ensuring consistent object placement

Testing

• Verified that the fix properly interpolates animations to their final state when cached
• Tested that normal (non-cached) animations continue to work as expected
• The original failing scene should now render consistently on first and subsequent runs

Fixes

Closes #4160

Example Usage

The following code (from the original issue) should now render consistently on multiple runs with caching enabled:

class Sin2(Scene):
    def construct(self):
        ax = Axes(x_range=(-2, 2, 1), y_range=(-2, 2, 1), x_length=6)
        trigo_circle = Circle(radius=1.5)
        self.add(ax, trigo_circle, Dot(color=RED).shift(1.5*RIGHT))

        theta = ValueTracker(0)

        neg_point = always_redraw(
            lambda: Dot(
                trigo_circle.point_at_angle(-theta.get_value()),
                color=YELLOW
            )
        )

        neg_arc = always_redraw(
            lambda: Arc(radius=1.4, angle=-(theta.get_value() % TAU), stroke_width=2,
                color=YELLOW
            )
        )

        pos_neg = always_redraw(
            lambda: Tex(
                "^{-i \\theta}$",
                color=YELLOW
            ).move_to(0.6*neg_point.get_center())
        )

        self.add(pos_neg, neg_point, neg_arc)
        self.play(theta.animate(run_time=5).set_value(TAU))
        self.play(theta.animate(run_time=2).set_value(TAU+2.4))
        self.wait()