Type checking to perform a variation of the strategy pattern
I don't know if it will be useful for you, but here is one variant:
Add to your Entity base class a method called GetWriter. This method should return IEntityWriter.
This IEntityWriter should have method Write() without parameters.

Then an implementation of an Entity would be something like:   

class XXXEntity: Entity
{
   public override IEntityWriter GetWriter()
   {
      return new XXXEntityWriter(this);
   }
}


And then the method WriteEntities in your example would be

public void WriteEntities(IEnumerable&lt;Entity&gt; entities)
{
   foreach(Entity entity in entities)
      entity.GetWriter().Write();
}


The 'mappings' approach (no matter if it is in the code or in the xml file) have a couple of problems:
1. It's easy to do wrong configuration of mappings. You can map a XXXEntity to YYYEntityWriter.
2. It's easy to forget to add an EntityWriter when you add new Entity or you can forget to add the mapping. And this is a real problem.

By the way. Judging from the description of the task, a concrete EntityWriter have to know about a concrete Entity.
So mapping is not as flexible as it seems, because of this explicit connection between EntityWriter and Entity.
It's not a problem to use GetType(). The problem here is to separate (hide) connections between classes that should work together.