Creating every possible combination until a code word is found
You should learn about separating concerns. Currently your functions have two concerns, finding the right word and timing how long it takes. You can take out this part by writing a decorator, that allows timing any function you decorate it with.

Next, your bruteforce_by_precomputed and your dictionary_attack are really the same function, just with a different dictionary behind it. You could just let the function accept it as an argument. And let it accept the word do decrypt as well, while we are at it. Normally I would also move the reading of the file here, but since you might want to decrypt more than one word, it could be a good idea to read the files only once.

I would add a maximum length for the infinitely_increasing_brute and just call it brute_force. No point in waiting for the heat death of the universe just to crack that one password...

You should close the files you open. One easy way to do that is to use with.

You should put your main running code under a if __name__ == "__main__ guard. This allows you to easily import the functions defined here in another script, without executing the encryption itself.

You should have a look at the string module, it has many pre-defined sets of characters, including string.ascii_lowercase, string.punctuation and string.printable.

It is not exactly clear if your code file contains only a single word. I modified it so that it can contain many words, separated by newlines.

Putting this together, your code becomes:

import itertools
from time import clock
from string import ascii_lowercase, ascii_uppercase, digits, punctuation

printable = ascii_lowercase + ascii_uppercase + digits


def timeit(func):
    def wrapper(*args, **kwargs):
        starting_time = clock()
        result = func(*args, **kwargs)
        ending_time = clock()
        print('Duration: {}'.format(ending_time - starting_time))
        return result
    return wrapper


@timeit
def dictionary_attack(encrypted, dictionary):
    for attempt in dictionary:
        if attempt == encrypted:
            return attempt


@timeit
def increasing_brute(encrypted, max_len=10):
    for length in range(1, max_len + 1):
        for brute_attempt in itertools.product(printable, repeat=length):
            attempt = ''.join(brute_attempt)
            if attempt == encrypted:
                return attempt


@timeit
def custom_brute(encrypted, length):
    for brute_attempt in itertools.product(printable, repeat=length):
        attempt = ''.join(brute_attempt)
        if attempt == code:
            return attempt


if __name__ == "__main__":
    with open("C:\\Users\\User\\Desktop\\dictionary.txt") as dictionary:
        dictionary_words = dictionary.read().splitlines()
    with open("C:\\Users\\User\\Desktop\\precompute.txt") as precomputed:
        precomputed_words = precomputed.read().splitlines()
    with open("C:\\Users\\User\\Desktop\\code.txt") as code:
        for encrypted in code:
            word = dictionary_attack(encrypted, precomputed_words)
            if word is not None:
                print "The word is", word
                continue
            word = dictionary_attack(encrypted, dictionary_words)
            if word is not None:
                print "The word is", word
                continue
            word = custom_brute(encrypted, int(input("what length to force?")))
            if word is not None:
                print "The word is", word
                continue
            word = increasing_brute(encrpyted)
            if word is not None:
                print "The word is", word
                continue


This could be improved further by making the attack functions generators that yield attempts and a single attack function that performs the comparison using a sequence of functions:

def dictionary_attack(encrypted, dictionary):
    for attempt in dictionary:
        yield attempt


def increasing_brute(encrypted, max_len=10):
    for length in range(1, max_len + 1):
        for brute_attempt in itertools.product(printable, repeat=length):
            yield ''.join(brute_attempt)


def custom_brute(encrypted, *args):
    length = int(input("what length to force?"))
    for brute_attempt in itertools.product(printable, repeat=length):
        yield ''.join(brute_attempt)


@timeit
def attack(encrypted, attack_funcs, attack_args):
    for func, args in zip(attack_funcs, attack_args):
        for attempt in func(encrypted, *args):
            if attempt == encrypted:
                return attempt


if __name__ == "__main__":
    with open("C:\\Users\\User\\Desktop\\dictionary.txt") as dictionary:
        dictionary_words = dictionary.read().splitlines()
    with open("C:\\Users\\User\\Desktop\\precompute.txt") as precomputed:
        precomputed_words = precomputed.read().splitlines()

    attack_funcs = dictionary_attack, dictionary_attack, custom_brute, increasing_brute
    attack_args = [precomputed_words], [dictionary_words], [10], []
    with open("C:\\Users\\User\\Desktop\\code.txt") as code:
        for encrypted in code:
            word = attack(encrypted, attack_funcs, attack_args)