I would abstract the animation logic into a high order function and the possible directions in an object, then just lookup the corresponding function for each direction, in other words:

function move(to, dir) {

  function animate(props) {
    return function() {
      $('#player').animate(props, 'slow', function() {
        $(this).attr('style', '').appendTo('#'+ to);
      });
    }
  }

  var dirs = {
    right: animate({ left: '+='+ scale }),
    left: animate({ left: '-='+ scale }),
    up: animate({ top: '-='+ (9*scale/10) }),
    down: animate({ top: '+=' + (9*scale/10) })
  };

  if (dir in dirs) dirs[dir]();
}

I fixed a few other things. You can use $(this) to refer to the element being animated in the callback and chain those methods.

Then (9*(scale/10)) is effectively the same as 9*scale/10; associative operators.

You probably need to abstract even more if you add more code; ideally you'd want separate all your logic from your DOM manipulation and create a clear data structure that you can reuse. Also think about using classes instead of IDs. Classes are more reusable and lead to simpler code.

$('#player')$('#player')$('#player')

$('#player')$('#player')$('#player')$('#player')
$('#player')$('#player')$('#player')$('#player')

Do not use $('#player') more than once in your code if you intend on fetching data or setting data to the DOM element more than once. Instead save your element to a javascript variable so you can quickly access it. If not, then your jQuery will search through the DOM over and over again.

var playerNode = $('#player');
playerNode.animate(stuff);

Anonymous Functions Are Evil

Notice how

function() {
  $("#player").appendTo("#" + moveTo);
  $('#player').attr("style", "");
}

is exactly the same as

function() {
  $("#player").appendTo("#" + moveTo);
  $('#player').attr("style", "");
}

That means you don't need to write the same line twice. Just create one function object and call itself for each method.

var animCallback = function() {
  $("#player").appendTo("#" + moveTo);
  $('#player').attr("style", "");
};

But wait! There's more! We can clean up that nasty callback because jQuery supports chaining, which allows you to just write one-liners with ease. In fact, while we're at it, we may as well use that variable that holds the player DOM node instead of searching for it again.

var animCallback = function() {
  playerNode.appendTo("#" + moveTo).attr("style", "")
};

playerNode.animate({ left: "+=" + scale }, "slow", animCallback);

If V.S. Case

Now here's a discrepancy. Some people say that switch case is faster than if else. However, you'll notice that newer browsers are focusing on improving the speed of if else by very large amounts. Some browsers are even faster with if else than switch case. Speed isn't the problem here, it's readability. Use an if else statement if there's only 4 possibilities because it makes more sense.

if(direction === 'left') {
  playerNode.animate({ left: "+=" + scale }, "slow", animCallback);
} else if(direction === 'right') {
  playerNode.animate({ right: "+=" + scale }, "slow", animCallback);
} ...

jQuery

You can make a game in your web browser, it'll just be slower than a C++ program. Likewise, you can make a game with jQuery, but it'll be slower than raw Javascript or your own custom libraries. I'm personally okay with jQuery being a setup for a game because it can normalize values that would appear different from browsers. Keep in mind, though, that document.getElementById('player') is about 10 times faster than $('#player').

All Together Now

var playerNode = $(document.getElementById('player'));

function move(moveTo, direction) {
  var animCallback = function() {
    playerNode.appendTo("#" + moveTo).attr("style", "")
  };

  if(direction === 'left') {
    playerNode.animate({ left: "-=" + scale }, "slow", animCallback)
  } else if(direction === 'right') {
    playerNode.animate({ left: "+=" + scale }, "slow", animCallback)
  } else if(direction === 'up') {
    playerNode.animate({ top: "-=" + (9 * (scale / 10)) }, "slow", animCallback)
  } else {
    playerNode.animate({ top: "+=" + (9 * (scale / 10)) }, "slow", animCallback)
  }
}

I'm not sure why you are set against creating an object to use here. It is really the best option for you here.

But since you asked for this specifically.

function move(moveTo, direction) {

    var doAfter = function() {
        $("#player").appendTo("#" + moveTo);$('#player').attr("style", "");
    }

    switch (direction) {
        case "right":
            $('#player').animate({ left: "+=" + scale }, "slow", doAfter);
            break;
        case "left":
            $('#player').animate({ left: "-=" + scale }, "slow", doAfter);
            break;
        case "up":
            $('#player').animate({ top: "-=" + (9 * (scale / 10)) }, "slow", doAfter);
            break;
        case "down":
            $('#player').animate({ top: "+=" + (9 * (scale / 10)) }, "slow", doAfter);
            break;
    }
}

You are concerned about the repeated calls to .appendTo() and .attr() but you should also be concerned about your calls .animate() which are very repetitive as well.

Basically you are mapping the four directions to modifications of top and right.

To keep that mapping simple I propose this:

directionMap = 
{
  right : { attribute : "left" , operator: "+=" , scaleMultiplier : 1 },
  left  : { attribute : "left" , operator: "-=" , scaleMultiplier : 1 },
  up    : { attribute : "top"  , operator: "-=" , scaleMultiplier : 0.9 },
  down  : { attribute : "top"  , operator: "+=" , scaleMultiplier : 0.9 }
}

This mapping should be done once, without knowing your code, I cannot tell you where.

Then, in the move function, you can retrieve the details for the given direction, construct the properties object with the proper css name/value pair.

function move(moveTo, direction) 
{
  var approach = directionMap[direction];
  if( approach )
  {
    var properties = {};
    properties[approach.attribute] =  approach.operator + ( scale * approach.scaleMultiplier );
    $('#player').animate( properties , "slow", function () 
    {
      $(this).appendTo("#" + moveTo).attr("style", "");
    });  
  }
}

The only other thing to note is that this in the callback function is the animated DOM element, and constructing a jQuery selector from an element is faster than constructing it from an ID.