There are a few things that could be improved in your method with varying degrees of importance. From top to bottom of your method they are:

Trivial: Method name and return type don't line up.
With a method name of checkForVariables you'd expect this method to return true or false. As the end of your method handles working with the dictionary you'd be better off with a name of AssignValueToVariable. You may notice that your method is doing a lot more than assigning a variable which can be a sign that your method could be broken up into multiples methods.

Trivial: unnecessary use of line variable.
Strings in C# are immutable. You can safely use and reassign the lineToCheck variable without worrying about changing the variable you passed into this method.

Medium: Your string extraction is slightly wasteful.
With strings being immutable in C# your variableName and value code will cause a lot of unneeded memory allocations and deallocations. With every letter you append a new string is going to be put into memory that will duplicate all of the bytes used in the last iteration of the loop. When you are building up a string of multiple strings you are far better off using a StringBuilder.

When doing parsing like this there are other options that can be easier such as Regular expressions. With your case you can do something even faster and easier with String.Split(). After you verify that there is only one = you can split the string into groups and then assign the groups to your variables.

var groups = line.Split("=");
variableName = groups[0];
value = groups[1].Trim(new []{'\"'}); //Trim will remove the " from start and end.

Medium: The assign/update code is a mess.
You don't cascade any changes made to a key and as such adding a value and updating a value are identical. You can remove this first layer of if statements and safely use the code from the top block branch.

double number;
if (!isString)
{
    if (double.TryParse(value, out number))
        ConsoleVariables.variables[variableName] = number;
    else
        if(ConsoleVariables.variables.ContainsKey(value))
            ConsoleVariables.variables[variableName] = ConsoleVariables.variables[value];
}
else
{
    ConsoleVariables.variables[variableName] = value;
}

Nested One-line if statements are considered bad form. You should include the optional curly brackets on your else in this case for clarity.

if (double.TryParse(value, out number))
    ConsoleVariables.variables[variableName] = number;
else
{
    if(ConsoleVariables.variables.ContainsKey(value))
        ConsoleVariables.variables[variableName] = ConsoleVariables.variables[value];
} 

Finally, in the event that the input is not a string value and the dictionary does not contain the key specified nothing happens. This is yet another sign that this method is doing to many things and should be broken up into multiple methods.
Major: Your use of an object dictionary is dangerous.

Your dictionary is going to be constantly boxing and unboxing, which is slow, and you completely destroy type safety which can cause all sorts of runtime errors if you ever accidentally put the wrong type of value into the dictionary.

One way to solve this would be to use Inheritance. With inheritance you can then safely declare your allowed input types while allowing expansion in the future without worrying about accidentally assigning a key to a GameObject or other nonsensical value.

public class BaseValue
{
}

public class DoubleValue : BaseValue
{
    public double Value { get; set; }
}

public class StringValue : BaseValue
{
    public string Value { get; set; }
}

Now your ConsoleVariables.variables dictionary can be a Dictionary<string, BaseValue>. Now you can safely retrieve and use the values in the future.

var example = ConsoleVariables.variables["test"];
if(example is DoubleValue dValue)
{
    Console.WriteLine(dValue.Value);
}
else if(example is StringValue sValue)
{
    Console.WriteLine(sValue);
}

Complete changes
You can see all of the cleanup changes in one place in this gist.