Factorial

// `tailopt()` is the identity function, used as a marker.
function tailopt (x) { return x; };

function fact_tailrec (n)    // Not marked for optimization
{
    return loop( n, 1 );   
    function loop( k, acc ) { return k < 2 ? acc : loop( k-1, k*acc ); }
}

var fact_tailopt = tailopt(     // Marked for optimization
    function (n)
    {
        return loop( n, 1 );
        function loop( k, acc ) { return k < 2 ? acc : loop( k-1, k*acc ); }
    }
);

Greatest Common Divisor (GCD)

// `tailopt()` is the identity function, used as a marker.
function tailopt (x) { return x; };

function gcd_tailrec (a,b)     // Not marked for optimization
{
    if (a > b) return gcd_tailrec( a-b, b);
    if (a < b) return gcd_tailrec(b - a, a);
    return a;
}


var gcd_tailopt = tailopt(     // Marked for optimization
    function (a,b) 
    {
        if (a > b) return gcd_tailopt( a-b, b);
        if (a < b) return gcd_tailopt(b - a, a);
        return a;
    }
);

...etc. From now one I'll only give the tailopt() version:

String replication

var stringrepli_tailopt = tailopt( 
    function(s0, n0)
    {
        if (!((n0 > 0) && s0)) { return ''; }
        return loop(s0, n0, []);
        function loop(s, n, tmp){
            if (n & 1) { tmp.push(s); }
            return n ? loop(s + s, n >> 1, tmp) : tmp.join('');
        }
    }
);

Odd/Even

var isEven_tailopt = (function () 
                      {
                          // Proof of concept: test the mutual tail-recursion of 2 functions.
                          
                          var isEven = tailopt( function (n) 
                                                {
                                                    if (n > 0) return isOdd(n-1);
                                                    if (n < 0) return isEven(-n);
                                                    return true;
                                                });

                          var isOdd = tailopt( function (n)
                                               {
                                                   if (n > 0) return isEven(n-1);
                                                   if (n < 0) return isOdd(-n);
                                                   return false;
                                               });

                          return isEven;
                      })();

Modulo 3

var is_0_mod_3_tailopt = (function () 
                          {
                              // Proof of concept: test the mutual tail-recursion of 3 functions.
                              
                              var is_0_mod_3 = tailopt( 
                                  function (n) { if (n > 0) return is_2_mod_3( n - 1 ); 
                                                 if (n < 0) return is_1_mod_3( n + 1 ); 
                                                 return true; }
                              );

                              var is_1_mod_3 = tailopt( 
                                  function (n) { if (n > 0) return is_0_mod_3( n - 1 ); 
                                                 if (n < 0) return is_2_mod_3( n + 1 ); 
                                                 return false; }
                              );

                              var is_2_mod_3 = tailopt( 
                                  function (n) { if (n > 0) return is_1_mod_3( n - 1 ); 
                                                 if (n < 0) return is_0_mod_3( n + 1 ); 
                                                 return false; }
                              );
                              
                              return is_0_mod_3;
                          })();

Sorted Search

Array.prototype.sortedSearch_tailopt = tailopt(
    function (x, less, equal)
    {
        // Assume `this` is a sorted array. Search for the first and
        // last occurences of `x`.
        //
        // If `x` found, return `[ first_index, last_index ]`
        // (integers).
        //
        // If `x` not found, return `null`.
        
        less  = less || function (a,b) { return a < b; };
        equal = equal || function (a,b) { return a == b; };
        
        var sortedArray = this;

        return searchFirst(0, sortedArray.length - 1, false, false);
        
        // Implementation: joint binary search.

        function searchFirst(i, j, first_found, last_found)
        {
            first_found = first_found || isFirstFound(i);
            
            // Termination tests

            if (i > j)
                return null;    // Done: `x` not found.

            if (first_found && last_found)
                return [i, j];  // Done: `x` found.

            // Update

            if (!first_found) 
            {
                i++;
                
                var ind = i + ((j - i) >> 1)
                , v_ind = sortedArray[ind]
                ;
                
                if (less(v_ind, x) || isFirstFound(ind))
                    i = ind; // Update
            }

            return searchLast(i, j, first_found, last_found);
        }

        function searchLast(i, j, first_found, last_found)
        {
            last_found = last_found || isLastFound(j);
            
            // Termination tests already done in `searchFirst` -> not needed here.

            // Update

            if (!last_found)
            {
                j--;
                
                var ind = j - ((j - i) >> 1)
                , v_ind = sortedArray[ind]
                ;

                if (less(x, v_ind) || isLastFound(ind))
                    j = ind; // Update
            }

            return searchFirst(i, j, first_found, last_found);
        }

        function isFirstFound(i)
        {
            return equal(x, sortedArray[i])  &&  (i < 1  ||  !equal(x, sortedArray[i - 1]));
        }
        
        function isLastFound(j)
        {
            return equal(x, sortedArray[j])  &&  (j > sortedArray.length - 2  ||  
                                                    !equal(x, sortedArray[j + 1]));
        }
    }
);