Convert template type to derived type when calling a function?

Your code would work if E were a concrete Entity subtype, e.g Enemy or Bunker. However, if E is the Entity base type then the overload cannot be selected. Ideally, just call the template function with the a suitable subtype.

If you need to be able to deal with E=Entity, you might as well get rid of the template. You can instead use the visitor pattern so that the Entity chooses the correct overload. First, define a visitor interface:

struct Visitor {
  virtual ~Visitor() {}
  virtual void VisitEnemy(Enemy&) = 0;
  virtual void VisitBunker(Bunker&) = 0;
};

Next, make the Entity visitable:

class Entity {
  ...
  virtual void Accept(Visitor&) = 0;
  ...
};

And implement the method in all base classes. For example:

class Enemy : public Entity {
  ...
  void Accept(Visitor& v) override { v.VisitEnemy(*this); }
};

We can then define a Visitor that destroys an Entity:

class DestroyingVisitor : Visitor {
  Manager<Enemy> m_enemyManager;
  Manager<Bunker> m_bunkerManager;

public:

  DestroyingVisitor(...) ...

  void VisitEnemy(Enemy& enemy) override {
    m_enemyManager->DestroyEnemy(enemy);
  }

  void VisitBunker(Bunker& bunker) override {
    m_bunkerManager->DestroyBunker(bunker);
  }
};

Finally, your resolve method can be rewritten to use the visitor:

void ResolveEntityHit(Entity& entity, Projectile& projectile) {
    entity.DealDamage(projectile.GetProjectileDamage());

    if (entity.IsDead()) {
        // DestroyEntity(entity);
        entity.Accept(DestroyingVisitor(...));
    }

    m_projectileManager->DestroyProjectile(projectile);
}

The conceptual problem at the root of the question is that you are mixing object oriented techniques with templates. Templates rely on knowing a specific type at compile time, whereas the point of object oriented techniques is to abstract over the concrete type so that the dynamic type is only known at runtime. In code like this

unique_ptr<Entity> e = make_unique<Enemy>();
ResolveEntityHit(*e, projectile);

the dynamic type of the *e object is Enemy. But the compiler only knows that its static type is Entity. Therefore, the template parameter E was deduced to be Entity, written explicitly as ResolveEntityHit<Entity>(...). If however you had provided Enemy as the template parameter then the ResolveEntityHit function would have compiled correctly, but the call to that function would have been a type error.

To get the concrete type back from a polymorphic object, techniques like the visitor pattern can be used. A related pattern is the virtual copy constructor. We basically have to put all operations that need to know the dynamic type of an object into that object. The visitor pattern in particular can be helpful here because we need to make an object visitable once and can reuse the visitor interface for multiple operations. But this comes at the tradeoff that you cannot simply add another Entity subtype without updating all of your visitors.

Do entities contain some sort of reference to their managers? If so, you could instead call entity->DestroySelf() and the entity would simply call manager->DestroyEntity(self) or something along those lines.

Or if they don't keep references to their managers (maybe because they can be owned by more than one?), then you could have a function which searches each manager for the entity. So you might have the managers stored in a vector of managers and call each one like this:

for (auto& nextManager : managers)
{
    if (nextManager.contains(entity))
    {
        nextManager.destroyEntity(entity);
    }
}