Is it an anti-pattern to let ViewModel fill itself from a domain object?
It's not an anti pattern. At some point, one layer must know about the layer underneath. You also don't want to rewrite view-model mapping code in multiple controllers or actions, nor do you want to introduce another layer to do the mapping for you. Instead, I opt for constructor injection.

The part of your code I do think is an anti pattern, or incorrect architecture, would be your view model having access to the data access layer.

Your last example using constructor injection will provide the least coupling and most code reuse:

public class EditEmployeeViewModel
{
    public EditEmployeeViewModel(Employee employee)
    {
        Id = employee.Id;
        // ...
    }
}


I would not include the reverse mapping in your view model, where you update an Employee domain model from the EditEmployeeViewModel object. Instead, I would opt for a command or service object to do this work, which would have access to the data access layer:

public class CreateEmployeeCommand
{
    public CreateEmployeeCommand(IEmployeeRepository repository, EditEmployeeViewModel model)
    {
        this.repository = repository;
        this.model = model;
    }

    private EditEmployeeViewModel model;
    private IEmployeeRepository repository;

    public void Execute()
    {
        if (repository.FindBySSN(model.SocialSecurityNumber) != null)
        {
            // cannot add duplicate employee
        }

        Employee employee = new Employee()
        {
            FirstName = model.FirstName,
            LastName = model.LastName,
            SocialSecurityNumber = model.SocialSecurityNumber,
            // ...
        };

        repository.Create(employee);
    }
}


Your controller becomes simplified. The key here is your data access layer should be created and destroyed at the controller level, not the command level. The controller should be controlling the transaction:

public class EmployeesController : Controller
{
    public ActionResult Create(EditEmployeeViewModel model)
    {
        if (!ModelState.IsValid)
            return View(model);

        using (IEmployeeRepository repo = new EmployeeRepository())
        {
            var command = new CreateEmployeeCommand(repo, model);

            command.Execute();

            repo.Commit();
        }

        return RedirectToAction("Index");
    }
}