Nested anonymous methods

One consideration is performance. Your current code is scanning the list as part of RemoveAll (that's O(n)) and for each item it is calling Exists on the list (that's also O(n) because it has to loop the entire list). The Exists call has the potential to get cheaper as you get closer to done if items are removed but in the worst case it looks like an O(N^2) implementation. Instead, use a HashSet - this makes lookups O(1) and results in an O(n) implementation.

Also, use the framework Path class to get the parent folders instead of StartsWith - your current code treats c:\john as a parent of c:\johnny\appleseed and removes c:\johnny\appleseed from the list.

private static void CleanUpFolders(List<string> uniqueFolders)
{
    var folderLookup = new HashSet<string>(uniqueFolders);
    uniqueFolders.RemoveAll(x => String.IsNullOrEmpty(x) ||
                                 x.Generate(Path.GetDirectoryName)
                                     .Skip(1) // the original
                                     .TakeWhile(p => p != Path.GetPathRoot(p))
                                     .Any(folderLookup.Contains));
}

assuming generically reusable Generate extension method

public static class TExtensions
{
    public static IEnumerable<T> Generate<T>(this T initial, Func<T, T> next) 
    {
        var current = initial;
        while (true)
        {
            yield return current;
            current = next(current);
        }
    }
}

test:

public void Should_only_keep_parent_directories()
{
    var directories = new List<string>
        {
            null,
            "",
            @"c:\bob",
            @"c:\john",
            @"c:\johnny\appleseed",
            @"c:\bob\mike\nick",
            @"C:\a\c",
            @"c:\stuf\morestuff",
            @"c:\stuf\morestuff\sub1",
            @"c:\otherstuf",
            @"c:\otherstuf\sub1",
            @"c:\otherstuf\sub1a",
            @"c:\otherstuf\sub2"
        };

    CleanUpFolders(directories);
    directories.Count.ShouldBeEqualTo(6);
    directories.ShouldContainAll(new[]
        {
            @"c:\bob",
            @"c:\stuf\morestuff",
            @"c:\otherstuf",
            @"C:\a\c",
            @"c:\john",
            @"c:\johnny\appleseed"
        });
}    

is there an issue with using variables inside anonymous methods that were declared outside?

no, if an anonymous method accesses a local variable then C# will create a separate class to host the method and variable allowing it all to "just work". (*)

any potential issues with nested anonymous methods?

The only issue I see with the nested anonymous methods is that it makes the code ugly and hard to read, but then I find linq in general has this effect :).

any other issues or best practices worth mentioning?

Since your paths are windows paths, you may want to consider using case insensitive comparisons.

This is how I would have done it, it works off the basis that if you sort the list then all strings that start with the string at position X will be in a single block that appears immediately after it.

private static void CleanUpFolders(List<string> uniqueFolders)
{
    uniqueFolders.RemoveAll(string.IsNullOrEmpty);
    uniqueFolders.Sort(StringComparer.OrdinalIgnoreCase);

    int write = 0;
    string last = null;

    for (int read = 0; read < uniqueFolders.Count; read++)
    {
        string value = uniqueFolders[read];

        if (last = null || value.StartsWith(last, StringComparison.OrdinalIgnoreCase))
        {
            uniqueFolders[write] = value;
            last = value;
            write++;
        }
    }

    if (write < uniqueFolders.Count)
    {
        uniqueFolders.RemoveRange(write, uniqueFolders.Count - write);
    }
}

(*) if you change the referenced variable after creating the delegate, it will affect what the delegate sees which can be non-obvious, particularly if you create a delegate in a loop that accesses the index or current item.

At the end of the loop in this example, all delegates will return 10;

Func<int>[] bob = new Func<int>[10];

for(int i = 0; i < bob.Length; i++)
{
    bob[i] = () => i;
}

But at the end of this loop each will return it's own index.

for(int i = 0; i < bob.Length; i++)
{
    int j = i;
    bob[i] = () => j;
}

The other answers are already pretty much complete, but I'm wondering about the usage of your code.

Are these real folders, present on the system running the code? Do you have to receive the folders as a list of strings?

Brian Reichle already mentioned that string representation of folders are system dependant. Perhaps you are better of writing a solution based around the DirectoryInfo class.

This is a simple recursive solution using an extension method:

public static List<DirectoryInfo> GetTopFolders( this DirectoryInfo dir )
{
    List<DirectoryInfo> result = new List<DirectoryInfo>();

    DirectoryInfo[] subDirs = dir.GetDirectories();
    if ( subDirs.Length > 0 )
    {
        result.Add( dir );
        subDirs.ForEach( d => result.AddRange( GetTopFolders( d ) ) );
    }

    return result;
} 

It uses the following IEnumerable extension method:

public static void ForEach<T>( this IEnumerable<T> source, Action<T> action )
{
    foreach ( var item in source )
    {
        action( item );
    }
}

UPDATE:

Or even better using Linq and the EnumerateDirectories function. Note that the passed dir argument isn't included in this result.

public static IEnumerable<DirectoryInfo> GetTopFolders( this DirectoryInfo dir )
{
    return from d in dir.EnumerateDirectories("*", SearchOption.AllDirectories)
           where d.EnumerateDirectories().Any()
           select d;
}