To wrap up the topic of NuGet dependency tracking, I added NuGet Dependency Matrix to my CodeVision impact analysis tool. The dependency matrix is simply a table with NuGet packages in rows and projects in which these packages are referenced in columns:
DependencyMatrix

The overall use case behind this if you own quite a bit of projects that have public and private NuGet packages, releasing new packages becomes challenging since you need to know what projects should be recompiled when a new NuGet is released. Dependencies between projects and packages are collected nightly during master build. Since number of projects and packages can be significant, there package has package and project filters.

The markup of this page is just 12 lines:

<table class="table table-striped table-bordered">  
        <tr class="success">
            <td></td>
            <th ng-repeat="project in dm.projects">{{project.value}}</th>
        </tr>
        <tr ng-repeat="package in dm.packages">
            <th class="success">{{package.value}}</th>
            <td ng-repeat="project in dm.projects">
                <span ng-if="dm.matrix[package.id][project.id]" class="glyphicon glyphicon-ok"></span>
            </td>
        </tr>
    </table>

and is driven by this class

public class DependencyMatrix  
{
    public bool[,] Matrix => BuildMatrix();
    public List<DependencyMatrixItem> Rows { get; private set; }
    public List<DependencyMatrixItem> Columns { get; private set; }

    private readonly List<Tuple<int, int>> _dependencies;

    public DependencyMatrix()
    {
        _dependencies = new List<Tuple<int, int>>();
        Rows = new List<DependencyMatrixItem>();
        Columns = new List<DependencyMatrixItem>();
    }

    public void AddDependency(string rowValue, string columnValue)
    {
        int rowId = AddItem(Rows, rowValue);
        int columnId = AddItem(Columns, columnValue);
        _dependencies.Add(new Tuple<int, int>(rowId, columnId));
    }

    public void Sort()
    {
        Rows = Rows.OrderBy(s => s.Value).ToList();
        Columns = Columns.OrderBy(s => s.Value).ToList();
    }

    private int AddItem(List<DependencyMatrixItem> items, string newItemValue)
    {
        var itemInTheList = GetItem(items, newItemValue);
        if (itemInTheList == null)
        {
            var newId = items.Any() ? items.Max(m => m.Id) + 1 : 0;
            items.Add(new DependencyMatrixItem(newId, newItemValue));
            return newId;
        }
        return itemInTheList.Id;
    }

    private bool[,] BuildMatrix()
    {
        if (!_dependencies.Any())
        {
            return new bool[,] {};
        }

        int rows = _dependencies.Max(m => m.Item1) + 1;
        int columns = _dependencies.Max(m => m.Item2) + 1;
        var matrix = new bool[rows, columns];

        foreach (var tuple in _dependencies)
        {
            matrix[tuple.Item1, tuple.Item2] = true;
        }

        return matrix;
    }

    private DependencyMatrixItem GetItem(List<DependencyMatrixItem> items, string value)
    {
        return items.SingleOrDefault(s => s.Value == value);
    }
}