Ich habe mich eine Nacht lang damit beschäftigt, den Heiligen Gral der Unity Entwicklung - den Unity Gral - zu suchen, und ihn gefunden.
Was ich als Unity Gral bezeichne, ist die Verwendung von Visual Studio Solutions, Asset-Management und einem Unity Projekt, ohne zusehr die Vorteile der Versions Kontrolle auszuhebeln. Vorteil des Unity Gral ist die einfache Nutzung des Repositories für Artists, als auch für Entwickler und Game Designer/Entwickler.

Eine Kleine Vorschau dazu:

Die fünf Branches sind für die Erstinstallation und weitere Nutzung von höchster Wichtigkeit.
In den Assets wird alles gespeichert, was nicht im Unity Repository angesiedelt sein soll und von Artists bearbeitet werden darf.
Im Project-Branch wird eine Visual Studio-Solution aufgesetzt, die entsprechend für Bibliotheken im Unity-Branch verwendet wird. Wichtig hierbei ist, dass alle Projekte nach /bin/ bzw. /bin/Editor/ exportieren.
ProjectAssemblies und UnityAssemblies halten die jeweils nötigen Bibliotheken für das Projekt. In UnityAssemblies also die gerade verwendeten Bibliotheken von Unity (für die Referenzierung im eigenen Projekt sehr wichtig!). ProjectAssemblies hält damit alle Bibliotheken die Unity importieren und verwenden soll (sowohl Game als auch Editor).
Der Unity-Branch ist damit das Herzstück des Repositories: Das Projekt innerhalb von Unity.

Die Einrichtung des Repository erfolgt relativ einfach mit diesem PowerShell-Skript:

$user = "user"
$server = "github.com"
$repo = "Namespace/Repository.git"

# Setup

ni -I D Assets
cd Assets
git init
ni -I F .gitignore
ni -I F README.md
git add .
git commit -m "Initial"
git remote add origin https://$user@$server/$repo
git branch -m "Assets"
git push --set-upstream origin Assets
cd ..

ni -I D Project
cd Project
git init
wget https://www.gitignore.io/api/visualstudio -o .gitignore
ni -I F README.md
git add .
git commit -m "Initial"
git remote add origin https://$user@$server/$repo
git branch -m "Project"
git push --set-upstream origin Project
cd ..

ni -I D Unity
cd Unity
git init
wget https://www.gitignore.io/api/unity -o .gitignore
ni -I F README.md
git add .
git commit -m "Initial"
git remote add origin https://$user@$server/$repo
git branch -m "Unity"
git push --set-upstream origin Unity
cd ..

ni -I D ProjectAssemblies
cd ProjectAssemblies
git init
ni -I F .gitignore
ni -I F README.md
git add .
git commit -m "Initial"
git remote add origin https://$user@$server/$repo
git branch -m "ProjectAssemblies"
git push --set-upstream origin ProjectAssemblies
cd ..

ni -I D UnityAssemblies
cd UnityAssemblies
git init
ni -I F .gitignore
ni -I F README.md
git add .
git commit -m "Initial"
git remote add origin https://$user@$server/$repo
git branch -m "UnityAssemblies"
git push --set-upstream origin UnityAssemblies
cd ..

# Configuration

cd Project
git submodule add -f -b ProjectAssemblies https://$server/$repo bin
git commit -m "Project Assemblies Submodule"
git submodule add -f -b UnityAssemblies https://$server/$repo packages/UnityAssemblies
git commit -m "Unity Assemblies Submodule"
git push origin
cd ..

cd Unity
git submodule add -f -b UnityAssemblies https://$server/$repo Library/UnityAssemblies
git commit -m "Unity Assemblies Submodule"
git subtree add --prefix Assets/Resources https://$server/$repo Assets
git subtree add --prefix Assets/Managed https://$server/$repo ProjectAssemblies
git push origin
cd ..

Dies sollte im Ideal-Fall in einem neuen Ordner ausgeführt werden, da alles relativ aufgebaut ist.
Die drei Variablen am Anfang sollten natürlich entsprechend des eigenen Bedarfs geändert werden. Für SSH-Verbindungen ist dieses Skript allerdings nicht ausgelegt, kann aber entsprechend geändert werden.

Wenn Unity nun das Projekt anlegen soll, ist es wichtig, dass Unity im PATH ist:

# Create Project
unity -quit -batchmode -createProject Unity

Mit Visual Studio muss manuell ein Projekt erstellt und im entsprechenden Ordner gespeichert werden.

Werden manuell neue Assemblies in den ProjectAssemblies-Branch eingefügt (Abhängigkeiten von Bibliotheken/gemeinsam genutztes Zeug), muss folgendes gemacht werden:

# Update ProjectAssemblies (manually)
cd ProjectAssemblies
git pull
git add .
git commit -m "Message"
git push origin
cd ../Unity
git subtree pull -P Assets/Managed https://$server/$repo ProjectAssemblies

Die Message sollte natürlich angepasst werden. Grundsätzlich geht das Skript in den ProjectAssemblies-Ordner, fügt alle Dateien hinzu und erstellt dann entsprechend einen Commit, der sofort gepusht wird. Geht anschließend in den Unity-Ordner und aktualisiert sofort den Subtree Assets/Managed.
Hier für sollten in Unity aber keine Änderungen registriert sein.

Für den seltenen Fall, dass an den Solutions etwas geändert wird, ist folgendes Skript recht nützlich:

cd .\Project\
git add .
git commit -m "Fixes Model in Editor"
cd .\bin\
git add .
git commit -m "Move Model to Editor"
git push
cd ..
git add .
git commit -m "Update bin to latest version"
git push
cd ..\Unity\
git subtree pull -P Assets/Managed https://$server/$repo ProjectAssemblies