A recent stackoverflow question, which I didn’t bookmark and now I’m unable to find, inspired me to implement an extension method for Enumerable that allows to insert a constant element between each pair of elements in a sequence. Kind of what String.Join does for strings, but maintaining an enumerable as the return value.
Having done the single element part I got a bit carried away and ended up expanding it adding overloads to support interleaving elements of another sequence and support for a predicate to control when interleaving takes place.
I have to confess that I did this for fun and now I can’t think of any real usage scenario, nonetheless, it may prove useful for someone. 
First a simple example:
var target = new string[] { "(", ")", "(", ")" };
var result = target.Interleave(".", (f, s) => f == "(");
// Prints: (.)(.)
Console.WriteLine(String.Join(string.Empty, result));
And now the untested but documented implementation:
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
public static class EnumerableExtensions
{
    /// <summary>
    /// Iterates infinitely over a constant element.
    /// </summary>
    /// <typeparam name="T">
    /// The type of element in the sequence.
    /// </typeparam>
    private class InfiniteSequence<T> : IEnumerable<T>, IEnumerator<T>
    {
        public InfiniteSequence(T element) { this.Element = element; }
        public T Element { get; private set; }
        public IEnumerator<T> GetEnumerator() { return this; }
        IEnumerator IEnumerable.GetEnumerator() { return this; }
        T IEnumerator<T>.Current { get { return this.Element; } }
        void IDisposable.Dispose() { }
        object IEnumerator.Current { get { return this.Element; } }
        bool IEnumerator.MoveNext() { return true; }
        void IEnumerator.Reset() { }
    }
    /// <summary>
    /// Interleaves the specified <paramref name="element"/> between each pair of elements in the <paramref name="target"/> sequence.
    /// </summary>
    /// <typeparam name="T">
    /// The type of elements in the sequence.
    /// </typeparam>
    /// <param name="target">
    /// The target sequence to be interleaved.
    /// </param>
    /// <param name="element">
    /// The element used to perform the interleave operation.
    /// </param>
    /// <exception cref="ArgumentNullException">
    /// <paramref name="target"/> or <paramref name="element"/> is a null reference.
    /// </exception>
    /// <returns>
    /// The <paramref name="target"/> sequence interleaved with the specified <paramref name="element"/>.
    /// </returns>
    public static IEnumerable<T> Interleave<T>(
        this IEnumerable<T> target,
        T element)
    {
        if (target == null)
            throw new ArgumentNullException("target");
        if (element == null)
            throw new ArgumentNullException("element");
        return InterleaveInternal(target, new InfiniteSequence<T>(element), (f, s) => true);
    }
    /// <summary>
    /// Interleaves the specified <paramref name="element"/> between each pair of elements in the <paramref name="target"/> sequence.
    /// </summary>
    /// <remarks>
    /// The interleave operation is interrupted as soon as the <paramref name="target"/> sequence is exhausted; If the number of <paramref name="elements"/> to be interleaved are not enough to completely interleave the <paramref name="target"/> sequence then the remainder of the sequence is returned without being interleaved.
    /// </remarks>
    /// <typeparam name="T">
    /// The type of elements in the sequence.
    /// </typeparam>
    /// <param name="target">
    /// The target sequence to be interleaved.
    /// </param>
    /// <param name="elements">
    /// The elements used to perform the interleave operation.
    /// </param>
    /// <exception cref="ArgumentNullException">
    /// <paramref name="target"/> or <paramref name="element"/> is a null reference.
    /// </exception>
    /// <returns>
    /// The <paramref name="target"/> sequence interleaved with the specified <paramref name="elements"/>.
    /// </returns>
    public static IEnumerable<T> Interleave<T>(
        this IEnumerable<T> target,
        IEnumerable<T> elements)
    {
        if (target == null)
            throw new ArgumentNullException("target");
        if (elements == null)
            throw new ArgumentNullException("elements");
        return InterleaveInternal(target, elements, (f, s) => true);
    }
    /// <summary>
    /// Interleaves the specified <paramref name="element"/> between each pair of elements in the <paramref name="target"/> sequence that satisfy <paramref name="predicate"/>.
    /// </summary>
    /// <typeparam name="T">
    /// The type of elements in the sequence.
    /// </typeparam>
    /// <param name="target">
    /// The target sequence to be interleaved.
    /// </param>
    /// <param name="element">
    /// The element used to perform the interleave operation.
    /// </param>
    /// <param name="predicate">
    /// A predicate used to assert if interleaving should occur between two target elements.
    /// </param>
    /// <exception cref="ArgumentNullException">
    /// <paramref name="target"/> or <paramref name="element"/> or <paramref name="predicate"/> is a null reference.
    /// </exception>
    /// <returns>
    /// The <paramref name="target"/> sequence interleaved with the specified <paramref name="element"/>.
    /// </returns>
    public static IEnumerable<T> Interleave<T>(
        this IEnumerable<T> target,
        T element,
        Func<T, T, bool> predicate)
    {
        if (target == null)
            throw new ArgumentNullException("target");
        if (element == null)
            throw new ArgumentNullException("element");
        if (predicate == null)
            throw new ArgumentNullException("predicate");
        return InterleaveInternal(target, new InfiniteSequence<T>(element), predicate);
    }
    /// <summary>
    /// Interleaves the specified <paramref name="element"/> between each pair of elements in the <paramref name="target"/> sequence that satisfy <paramref name="predicate"/>.
    /// </summary>
    /// <remarks>
    /// The interleave operation is interrupted as soon as the <paramref name="target"/> sequence is exhausted; If the number of <paramref name="elements"/> to be interleaved are not enough to completely interleave the <paramref name="target"/> sequence then the remainder of the sequence is returned without being interleaved.
    /// </remarks>
    /// <typeparam name="T">
    /// The type of elements in the sequence.
    /// </typeparam>
    /// <param name="target">
    /// The target sequence to be interleaved.
    /// </param>
    /// <param name="elements">
    /// The elements used to perform the interleave operation.
    /// </param>
    /// <param name="predicate">
    /// A predicate used to assert if interleaving should occur between two target elements.
    /// </param>
    /// <exception cref="ArgumentNullException">
    /// <paramref name="target"/> or <paramref name="element"/> or <paramref name="predicate"/> is a null reference.
    /// </exception>
    /// <returns>
    /// The <paramref name="target"/> sequence interleaved with the specified <paramref name="elements"/>.
    /// </returns>
    public static IEnumerable<T> Interleave<T>(
        this IEnumerable<T> target,
        IEnumerable<T> elements,
        Func<T, T, bool> predicate)
    {
        if (target == null)
            throw new ArgumentNullException("target");
        if (elements == null)
            throw new ArgumentNullException("elements");
        if (predicate == null)
            throw new ArgumentNullException("predicate");
        return InterleaveInternal(target, elements, predicate);
    }
    private static IEnumerable<T> InterleaveInternal<T>(
        this IEnumerable<T> target,
        IEnumerable<T> elements,
        Func<T, T, bool> predicate)
    {
        var targetEnumerator = target.GetEnumerator();
        if (targetEnumerator.MoveNext())
        {
            var elementsEnumerator = elements.GetEnumerator();
            while (true)
            {
                T first = targetEnumerator.Current;
                yield return first;
                if (!targetEnumerator.MoveNext())
                    yield break;
                T second = targetEnumerator.Current;
                bool interleave = true &&
                    predicate(first, second) &&
                    elementsEnumerator.MoveNext();
                if (interleave)
                    yield return elementsEnumerator.Current;
            }
        }
    }
}