I suspect that your issue is because you have not approved the transfer required to call transferFrom(...).

Here are the relevant functions:

    /* Send coins */
    function transfer(address _to, uint256 _value) {
        if (balanceOf[msg.sender] < _value) throw;           // Check if the sender has enough
        if (balanceOf[_to] + _value < balanceOf[_to]) throw; // Check for overflows
        balanceOf[msg.sender] -= _value;                     // Subtract from the sender
        balanceOf[_to] += _value;                            // Add the same to the recipient
        Transfer(msg.sender, _to, _value);                   // Notify anyone listening that this transfer took place
    }

    /* Allow another contract to spend some tokens in your behalf */
    function approveAndCall(address _spender, uint256 _value, bytes _extraData)
        returns (bool success) {
        allowance[msg.sender][_spender] = _value;
        tokenRecipient spender = tokenRecipient(_spender);
        spender.receiveApproval(msg.sender, _value, this, _extraData);
        return true;
    }

    /* A contract attempts to get the coins */
    function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
        if (balanceOf[_from] < _value) throw;                 // Check if the sender has enough
        if (balanceOf[_to] + _value < balanceOf[_to]) throw;  // Check for overflows
        if (_value > allowance[_from][msg.sender]) throw;   // Check allowance
        balanceOf[_from] -= _value;                          // Subtract from the sender
        balanceOf[_to] += _value;                            // Add the same to the recipient
        allowance[_from][msg.sender] -= _value;
        Transfer(_from, _to, _value);
        return true;
    }

If you are the current owner of the tokens, you can call transfer(...) to transfer your balance to another address.

However if you want to transfer from another address, you will need to call transferFrom(...) which will check the allowance[...][...] data structure to confirm whether this transfer has been approved.

So, call approveAndCall(...) first to approve your transfer and you should be able to call transferFrom(...) to transfer your tokens.

When you call transferFrom(...) without first calling approveAndCall(...), and error is thrown in the line

if (_value > allowance[_from][msg.sender]) throw;   // Check allowance

This error will appear as an Out Of Gas error in the Ethereum Wallet.

If you are comfortable using geth, see How can the transaction status from a thrown error be detected when gas can be exactly the same as the gasUsed for a successful transaction? for the following code that can be used to check the exact reason for your error:

> var status = debug.traceTransaction("0xd23219e2ea10528b245deb9e47993cae2ffd3ffe9fc27aeb808e94fc4e75d37b")
undefined
> if (status.structLogs.length > 0) {
  console.log(status.structLogs[status.structLogs.length-1].error)
}
"invalid jump destination (PUSH1) 2"

Has anybody used this code to crowdsale tokens and perform a withdrawal as a user?

IMO that code is more a sketch of an actual ICO and not meant as a secure and proper ICO reference implementation. It has at least one issue described below. Furthermore, I am not aware of anyone using exactly this code, most of the time the upper limit (cap) seems to be more relevant than the lower limit that is implemented here.

Do the token balance at token contract decrease properly when safeWithdrawal is called? How is that possible?

This contract tracks the paid contributions (in Wei) in addition to the separate token contract (see below for some issues regarding this implementation). Inside the safeWithdrawal function you have the following line that takes care of resetting the paid contribution when the funding limit has not been reached:

balanceOf[msg.sender] = 0;

This token sale contract aims at working with any token. Hence "destroying" the reimbursed tokens would have to be handled on a case-by-case basis in that token contract. Specifically, you as a user would have to first call the approve function of a standard token and now the contract here could attempt to burn the tokens by sending them to an unspendable address (e.g. 0x000...) or send it to itself.

Your point that upon reimbursing Ether, tokens are not destroyed/reimbursed is correct. However, you could argue that these tokens are simply meaningless if all Ether have been reimbursed. You could go even further and say that you actually save gas for every single investor that wants their Ether reimbursed - the token is meaningless anyway if the project did not get any Ether, so why reallocate token balances?

Now for

The issue:

This crowd sale contract overwrites contributed Ether per address instead of increasing the balance:

uint amount = msg.value;
balanceOf[msg.sender] = amount;

This is an issue for investors that send multiple transactions and would then lose funds in the reimbursement period. In fact all Ether except for the ones send in the last transaction would be unspendably locked in the smart contract forever.

I would therefore suggest

A fix:

uint amount = msg.value;
balanceOf[msg.sender] += amount;

Of course it would be good practice to a library like SafeMath instead of doing a simple increment.

Now you do not have to bother about reimbursing or destroying Ether anymore, any investor can always simply get their contributed amount back if the funding limit has not been reached. Of course every token holder should be aware that in that case they are simply involved in yet another totally Useless Ethereum Token.