transfer: preserve workspace data

[efiop]

Currently, we use move to transfer data from the workspace to the local odb. This means that if for some reason we've failed to transfer one file from the dataset, all of the completed files would disappear from the workspace and, because we save .dir last, there will be not enough metadata around to recover the original dataset structure.

This PR, makes us try to use reflink or a hardlink instead of move to keep the workspace structure intact, while also keeping the odb complete. So if the same type of failure occurs, the worst that could happen is that some of the files in the dataset will be in read-only mode, which is easily recoverable. This also allows us to introduce recovery functionality in the future, that could both rollback the dvc add or just continue it from where it left.

The main reason why we've used move was performance, as it allowed us to just create the links from scratch when doing the checkout part. Now, with the introduction of dvc.objects.diff, we can be smart about it and only relink if it makes sense. The details still will be optimized in the near future though.

Transferring in terms of copy operations before and after:

	move	{ref,hard}link
same fs	same as rename, no copy	no copy
same fs, no link	no copy	copy
different fs	copy	copy

So if we are on some sketchy fs where even hardlink doesn't work, but rename does - we'll indeed have to copy, but user's workspace stays intact and this is more important for transfer. But dvc add consists of transferring and checkout, so if user is using default cache.type(reflink or copy) - we'll have to copy from cache back to workspace after move anyway, so overall we will do the same 1 copy operation. On the other hand, after this PR we have a new situation when we might've used a hardlink during transfering but, the user wants a symlink so we'll need to relink, which is pretty cheap and checkout is already doing those checks for dvc checkout --relink anyway.

Overall, in order to keep the user workspace safer, this PR sacrifices hardlinking overhead in some cases, while also making transfering operation much more correct by not being destructive.

Also, please note, that same as object.diff, this will benefit from path_info removal and c/cython extensions in the near future.

Partial mitigation for #6387

[efiop]

Another thing we could do here is move original file aside (e.g. .data.back) so that even if _link fails - we could bring it back. Clearly there is a storage cost for it though. Though we don't relink copies anyway, so it should actually be fine. Though this should be done carefully. Will need to look into it after this PR.

[karajan1001]

Another thing we could do here is move original file aside (e.g. .data.back) so that even if _link fails - we could bring it back. Clearly there is a storage cost for it though. Though we don't relink copies anyway, so it should actually be fine. Though this should be done carefully. Will need to look into it after this PR.

But here we only create a link and that would not cost too much storage. Even in the worst condition the overall storage cost would only be a little more than before the operation.

Btw,

def _do_link(cache, from_info, to_info, link_method):
    if cache.fs.exists(to_info):
        cache.fs.remove(to_info)  # broken symlink
    link_method(from_info, to_info)
    logger.debug(
        "Created '%s': %s -> %s", cache.cache_types[0], from_info, to_info
    )

Looks similar to it.

[efiop]

Will unify this with the stuff we do in checkout in the followups, since it is out of scope.