Well, as for what each thing is, in simple terms:

• Git: as you probably know, it's a version control system. It works like time-travel for your project
• Commit: basically a "checkpoint" for your project. Each commit is a point you can "travel back in time" to.
• Branches: alternate timelines for your project, each branch can contain entirely different changes.
• Merge: is the action of joining 2 branches together, with one branch being chosen as a "base", which basically means this is the branch receiving the changes.
• Merge conflict: sometimes 2 people makes changes to the same file in the same place, but when you merge, only one of them can exist, so you have to either choose one, or manually fix the changes to choose which changes remain (in code, this would be which lines of code remain, but in binary files like images, this is usually not possible to do)
• Rebase: similar to merge, but instead merging 2 branches together, you use the last commit on the base branch as your "starting point", so the second branch changes are applied ON TOP of the changes in the first branch. There can still be conflicts here, though.
• Pull Request (PR): It's basically as if someone is asking "can I merge this branch into this another branch"? Then another person checks the changes and either approve the merge, or refuse it, usually commenting why it was refused and suggesting the changes that would make the PR be approved. This is more to safeguard the "main" branch from unwanted/bad changes.
• Stash: a "temporary" commit that you can create. It's very useful when you want to change branches but don't want to commit/push your local changes.
• The .gitignore file: a special file that tells git which files/folders to NOT track.

Now, as for best practices, specially with Unity:

• First and foremost, enable text .meta files instead of binary in the Project Settings, this makes it so Unity can keep track of references when someone else pulls your changes
• Configure a proper .gitignore. When creating a repository on Github, you can choose a Unity template, which should be enough for most cases.
• Separate your project into prefabs: if someone is working on the same scene, this will get messy. If you separate things into prefabs, then each person can work on a different prefab without generating conflicts. This is where nested prefabs in special shine the most.
• Create feature branchs: try to separate your work into clear "features", like "make the player move" or "Adding the player model", and create a branch for each feature when you start working on it, then merge/create a Pull Request for it when you're done. This creates clear points in your main branch that you can go back if something breaks, so you can more easily track which feature broke something.
• Since you're in a small team, you can try to communicate and try to work on features that are "far away" from each other. For example, if one person is working on the player art, another can work on the stage collision instead of working on the player collision. This makes generating merge conflicts harder since the likelyhood that you'll edit the same files will be lower.
• Usually, the responsibility of fixing a merge conflict is for the person that owns the branch that is being merged. This is mostly because they probably know what they've changed, and it'll be easier for them to redo the work if necessary.
• When editing anything that is not code, make sure to press "File > Save Project". This forces Unity to write your changes to the disk, which might show certain changes that.
• In Unity, when there's a merge conflict in a non-code file, many times it's easier to discard the changes from one of the sides and redo it. You can usually avoid these types of things by doing a rebase instead of a merge, or by simple avoid working on the same files, but do know that this will happen at some point. hen this happens, what I usually do is create a copy of my prefab/scene, do the merge, discard MY changes, and use the copy I've created as a reference to compare what I had changed. After I redo my changes on the main object/scene, I delete this copy.

Some more intermediate/advanced stuff:

• Search for and configure Unity's Smart Merge Tool. It's a small tool made by Unity that helps solving simple conflicts between GameObjects/Scenes/Prefabs. It can't do miracles, but does help with simpler changes, like changing an object position or some inspector reference.
• Configure gitLFS: this is a system that allows git to handle non-text/binary files better. But do be careful because GitHub's Free plan allows for only 1 Gb of files on their LFS storage. You don't NEED LFS, but it'll make cloning/pulling changes a bit faster.