Here's an idea:

I do this with all my code. This is a little confusing if you don't program, but it is actually faster than having lots of Update() calls.

1. I create an event manager, then have all then have all my class have a psuedo-update function that they add to the event. Then I fire the event and they all get fired.

2. Unity is single treaded. So if you call a function Unity will finish it before it continues onto its next task. So if you have two events, the second one should be called after the first one is completely finished working similar to a LateFixedUpdate().

Here is a sample:

using System;
using UnityEngine;
using System.Collections;

public class TickManager : MonoBehaviour {

    public event Action tick;
    public event Action lateTick;

    // Use this for initialization
    void Start () {
         StartCoroutine(FixedTick());
    }

    IEnumerator FixedTick() {
         for(;;) {
             if(tick != null)
                  tick();
             if(lateTick != null)
                  lateTick();
             yield return new WaitForFixedUpdate();
         }
    }
}

This will create 2 events. Then you can have classes register to them.

using System;
using UnityEngine;
using System.Collections;

public class SomeClass : MonoBehaviour {

    // Use this for initialization
    void Start () {

        TickManager eventManager = (TickManager)FindObjectOfType(typeof(TickManager));
        tickManager.tick += new Action (Tick);
        tickManager.lateTick += new Action(LateTick);

    }

    void Tick () {
            //This will get called as frequently as FixedUpdate
    }

    void LateTick () {
            //This should be called after the first one.
    }
}

By the way, if someone more knowledgeable than myself can tell me that my understanding of Unity's threading is completely wrong then please do ;).

EDIT: I managed to get it working with javascript. The first code needs to be in C# because I don't believe you can do events in javascript. But the second code can be in js with the following syntax:

var tickManager : TickManager;

function Start () {
    //using function types.  Similar to an implicit delegate.
    tickManager.tick += Tick;
    tickManager.lateTick += LateTick;

    //Also supports anonymous functions
    tickManager.tick += function() {
             Debug.Log("Tick");
        };
}

function Tick () {
    Debug.Log("Fired on a FixedUpdate interval");
}

function LateTick () {
    Debug.Log("Called after the prior method");
}