The stripping extensions

In HasComment, I find it odd that you have to iterate over the characters. Isn't there something like indexOf that returns the index or -1 otherwise? So that the loop could be replaced with this:

index = instruction.IndexOf(CommentMarker);
return index > -1;

A test for StripTrailingComment would be good too:

[TestMethod]
public void StripTrailingComment()
{
    var comment = "       'but this is one.";
    var instruction = "Debug.Print \"'this isn't a comment\"";
    var instructionWithComment = instruction + comment;

    var result = instructionWithComment.StripTrailingComment();

    Assert.AreEqual(instruction, result);
}

I'm guessing the part you dislike the most is the implementation of StripStringLiterals. I'd look for a clever regex for this, if that's even possible.

Short of that, it seems that these two if can be simplified by joining with else if:

if (line[cursor] == StringDelimiter)
{
    // ...
}

if (!isInsideString && line[cursor] != StringDelimiter)
{
    // ...
}

to get:

if (line[cursor] == StringDelimiter)
{
    // ...
}
else if (!isInsideString)
{
    // ...
}

And this line is too long to read:

isInsideString = cursor + 1 == line.Length || line[cursor + 1] == StringDelimiter || cursor > 0 && (line[cursor - 1] == StringDelimiter);

HasComment()

This method is named poorly. A HasComment() method implies only to return if a String has/contains a comment.

This method should be named following the Try pattern. So TryGetCommentIndex() would better reflect what the method does.

Why don't you use the built in methods ? The method can be simplified to

public static bool TryGetCommentIndex(this string line, out int index)
{
    index = line.StripStringLiterals().IndexOf(CommentMarker);

    return (index != -1);
}

StripStringLiterals()

The assignment of the isInsideString can be simplified and broken into multiple lines like

isInsideString = !isInsideString
                        || cursor + 1 == line.Length
                        || line[cursor + 1] == StringDelimiter
                        || cursor > 0 && (line[cursor - 1] == StringDelimiter);  

together with using an else if with a continue this method can be refactored to

public static string StripStringLiterals(this string line)
{
    var builder = new StringBuilder(line.Length);
    var isInsideString = false;
    for (int cursor = 0; cursor < line.Length; cursor++)
    {
        if (line[cursor] == StringDelimiter)
        {
            isInsideString = !isInsideString
                                    || cursor + 1 == line.Length
                                    || line[cursor + 1] == StringDelimiter
                                    || cursor > 0 && (line[cursor - 1] == StringDelimiter);
        }
        else if (!isInsideString)
        {
            builder.Append(line[cursor]);
            continue;
        }

        builder.Append(' ');
    }

    return builder.ToString();
}  

But wait, we can do better. Let us check what values will be passed to TryGetCommentIndex() method.

Possibilities

1. ' is missing -> no comment
2. ' with trailing " -> comment
3. ' without trailing " -> comment
4. ' with a leading " -> maybe a comment after the trailing "

Let us express these possibilities in code

1. line.IndexOf(CommentMarker) == -1
2. -1 < line.IndexOf(CommentMarker) < line.IndexOf(StringDelimiter)
3. (line.IndexOf(CommentMarker) == 0) || (-1 < line.IndexOf(CommentMarker) && line.IndexOf(StringDelimiter) == -1)
4. -1 < line.IndexOf(StringDelimiter) < line.IndexOf(CommentMarker)

This leads to

public static bool TryGetCommentIndex(this string line, out int index)
{
    index = line.IndexOf(CommentMarker);

    if (index == -1) { return false; } // possibility 1
    if (index == 0) { return true; }   // possibility 3.1

    int quoteIndex = line.IndexOf(StringDelimiter);

    if (quoteIndex > -1 && index > quoteIndex)
    {
        // possibility 4
    }

    // possibility 2 + 3.2
    return true;
}

So we only need to implement possibility 4.

What we know is that after a leading " there needs to be a trailing " because it is either a code line like Debug Print "Something I don't know" or it is a code line followed by a comment.

So we need to get the index of the next " which will be > -1 because otherwise it would be code which wouldn't compile ;-)

quoteIndex = line.IndexOf(StringDelimiter, quoteIndex + 1);

These leads to possibilities

1. quoteIndex > index
2. quoteIndex < index

Both possibilites can be a comment or not. We add 1 to quoteIndex and take the input string from there and call the method recursive.

which leads to

quoteIndex = line.IndexOf(StringDelimiter, quoteIndex + 1) + 1;

Boolean success = line.Substring(quoteIndex).TryGetCommentIndex(out index);  

if the recursive call returns true, we need to adjust the index to reflect the real position.

index = success ? index + quoteIndex : -1;

And altogether

public static bool TryGetCommentIndex(this string line, out int index)
{
    index = line.IndexOf(CommentMarker);

    if (index == -1) { return false; }
    if (index == 0) { return true; }

    int quoteIndex = line.IndexOf(StringDelimiter);

    if (quoteIndex > -1 && index > quoteIndex)
    {
        quoteIndex = line.IndexOf(StringDelimiter, quoteIndex + 1) + 1;

        Boolean success = line.Substring(quoteIndex).TryGetCommentIndex(out index);

        index = success ? index + quoteIndex : -1;

        return success;
    }

    return true;
}

Now we can skip the StripStringLiterals() method.

CommentMarker

This name is not specific enough. You should name it maybe CommentMarkerVB.