<< Miscellaneous`RealOnly`
<< Graphics`Colors`
Off[General::"spell1"];
ExportFrames[inFrames_] := 
      Module[{frames = inFrames, cells, 
          i}, 
Do[Show[frames[[i]]];, {i, 1, 
              Length[frames]}];
]

\(\(AnimateFrames[
          inFrames_] := 
Module[{frames = inFrames, cells, 
            i}, 
cells = 
            Table[Cell[
		GraphicsData[\ \ "PostScript", 
                  frames[\([i]\)]\ \ ], 
\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ "Graphics", 
		AnimationDisplayTime -> If[i == Length[frames], 1000000, 0.2]], 
{i, 
                1, Length[frames]}]; 
\ \ \ NotebookWrite[\ 
            EvaluationNotebook[], 
            CellGroupData[cells, 
              Closed]\ ];
];\)\)
makeHorizontalResiduals[inM_, inData_] := 
        Module[
{m = inM, data = inData, 
            n = Length[inData], 
            graphicalResiduals}, 
graphicalResiduals = 
            Table[Graphics[{Green, 
                  Line[{{data[[i]][[2]]/
                          m, data[[i]][[2]]}, 
                      data[[i]]}]}], {i, 1, 
                n}]; 
Return[
            graphicalResiduals];
];
makePerpendicularResiduals[inM_, inData_] := 
        Module[
{m = inM, data = inData, 
            n = Length[inData], 
            graphicalResiduals}, 
graphicalResiduals = 
            Table[Graphics[{Green, 
Line[{{(data[[i]][[1]] + 
                              m*data[[i]][[2]])/(m^2 + 
                              1), (data[[i]][[1]] + 
                              m*data[[i]][[2]])*
                          m/(m^2 + 1)}, data[[i]]}]}], {i, 1, 
                n}]; 
Return[
            graphicalResiduals];
];
makeVerticalResiduals[inM_, inData_] := 
        Module[
{m = inM, data = inData, 
            n = Length[inData], 
            graphicalResiduals}, 
graphicalResiduals = 
            Table[Graphics[{Green, 
                  Line[{{data[[i]][[1]], 
                        m*data[[i]][[1]]}, data[[i]]}]}], {i, 
                1, n}]; 
Return[
            graphicalResiduals];
];
CreateAnimationOfDifferentVerticalLines[inData_, inF_, inP_] := 
        Module[
{data = inData, f, p = inP, 
            m}, 
f[m_] = 
            inF[m, p]; 
CreateAnimationOfDifferentLines[
            data, f, 0];
];
CreateAnimationOfDifferentPerpendicularLines[inData_, inF_, inP_] := 
        Module[
{data = inData, f, p = inP, 
            m}, 
f[m_] = 
            inF[m, p]; 
CreateAnimationOfDifferentLines[
            data, f, 2];
];
CreateAnimationOfDifferentHorizontalLines[inData_, inF_, inP_] := 
        Module[
{data = inData, f, p = inP, 
            m}, 
f[m_] = 
            inF[m, p]; 
CreateAnimationOfDifferentLines[
            data, f, 1];
];
AnimateDistanceFunction[inData_, inF_] := 
        Module[
{data = inData, f, p = inP, 
            m}, 
f[m_] = 
            inF[m]; 
CreateAnimationOfDifferentLines[data, 
            f, 0, ""];
];

ExportAnimationOfDistanceFunction[inData_, inF_, inFile_] := 
        Module[
{data = inData, f, p = inP, m, 
            fileName = inFile}, 
f[m_] = 
            inF[m]; 
CreateAnimationOfDifferentLines[data, 
            f, 0, fileName];
];
\(\(CreateAnimationOfDifferentLines[inData_, inF_, inTest_, inFileName_] := Module[
{minM = 1, maxM = 2, itM = 0.01, nm, test = inTest, 
            data = inData, graphicalPoints, i, n = Length[inData], 
            graphicalLines, maxX, m, graphicalResiduals, graphicalText, 
            V = inF, leftGraphs, graphicalV, graphicalDot, rightGraphs, 
            twinGraphs, frames, 
            exportFile = inFileName}, 
nm = 
            Length[Range[minM, maxM, 
                itM]]; 
graphicalPoints = 
            Table[Graphics[{PointSize[0.018], Blue, 
                  Point[data[\([i]\)]]}], {i, 1, n}]; 
If[
            test == 0, 
            maxX = \(data[\([n]\)]\)[\([1]\)], 
\(If[
                test == 1, 
                maxX = \(data[\([n]\)]\)[\([2]\)], 
maxX = \((\(data[\([n]\)]\)[\([1]\)] + \(data[\([n]\)]\)[\([2]\)])\)/
                    2];\)]; 
graphicalLines = 
            Table[
Graphics[{Red, 
                  Line[{{\(-0.2\), \(-0.2\)\ m}, {maxX, maxX*\ m}}]}], {m, 
                minM, maxM, itM}]; 
If[
            test == 
              0, 
\(graphicalResiduals = 
                Table[makeVerticalResiduals[m, data], {m, minM, maxM, 
                    itM}];\), 
If[
              test == 
                1, 
\(graphicalResiduals = 
                  Table[makeHorizontalResiduals[m, data], {m, minM, maxM, 
                      itM}];\), 
\(graphicalResiduals = 
                  Table[makePerpendicularResiduals[m, data], {m, minM, maxM, 
                      itM}];\)]]; 
graphicalText = 
            Table[Graphics[{Purple, 
                  Text["m = " <> ToString[m] <> "
V = " <> 
                      ToString[N[V[m], 3]], {3, 0.2}, {\(-1\), \(-1\)}, 
                    Background -> LightPink, 
                    TextStyle -> {FontSize -> 16}]}], {m, minM, 
                maxM, itM}]; 
leftGraphs = 
            Table[Join[graphicalPoints, 
                graphicalResiduals[\([m]\)], {graphicalLines[\([m]\)]}, {graphicalText[\([m]\)]}], {m, 1, nm}]; 
leftGraphs = 
            Table[Show[leftGraphs[\([m]\)], Axes -> True, 
                DisplayFunction -> Identity, 
                PlotRange -> {{0, 12}, {0, 12}}, 
                AspectRatio -> Automatic], {m, 1, 
                nm}]; 
maxrightY = 
            Max[{V[0.9*minM], V[1.1*maxM]}]; 
graphicalV = 
            Plot[V[m], {m, minM, maxM}, DisplayFunction -> Identity, 
              PlotRange -> {{0.9*minM, 1.1*maxM}, {\(-maxrightY\), 
                    maxrightY}}, 
              PlotStyle -> {Green}]; 
graphicalDot = 
            Table[Graphics[{PointSize[0.018], Magenta, 
                  Point[{m, V[m]}]}], {m, minM, maxM, 
                itM}]; 
rightGraphs = 
            Table[{graphicalV, graphicalDot[\([i]\)]}, {i, 1, 
                nm}]; 
rightGraphs = 
            Table[Show[rightGraphs[\([i]\)], 
                DisplayFunction -> Identity], {i, 1, 
                nm}]; 

twinGraphs = 
            Table[GraphicsArray[{leftGraphs[\([i]\)], 
                  rightGraphs[\([i]\)]}], {i, 1, 
                nm}]; 
frames = 
            Table[Show[twinGraphs[\([i]\)], 
                DisplayFunction -> DisplayString, 
                ImageSize -> {900, 500}], {i, 1, 
                nm}]; 
If[
            exportFile == "", 
\(AnimateFrames[
                frames];\), 
\(Export[
                exportFile, {twinGraphs[\([1]\)], 
                  twinGraphs[\([4]\)]}, "GIF", "AnimationDisplayTime" -> 5
];\)
];
];\)\)

Plotting the Data:

rootData := {{0, 0}, {1, 1.2}, {2, 3.8}, {3, 4.2}, {4, 6.3}, {5, 
            7.2}, {6, 7.3}};
p1 = 
        ListPlot[rootData, PlotStyle -> {PointSize[0.02], Blue}, 
          AxesLabel -> {"Time (days)", "Growth (mm)"}, 
          PlotLabel -> "Root growth over time",  
          TextStyle -> {FontSize -> 18}, 
          ImageSize -> {900, 600}];

Show one model:

m = 1.25;
p2 = 
        Plot[m*x, {x, 0, 6}, PlotStyle -> {Red}, 
          DisplayFunction -> Identity];
Show[{p1, p2}];

Show the residual lines (i.e., lines joining the data points to the graph of the model):

p3 = makeVerticalResiduals[m, rootData];
Show[{p1, p2, p3}];

Plotting your answers for slope (m) against Total Distance ((Subscript[V, 2])(m)):

yourData = {{1.38, 1.666}, {1.42, 1.687}, {1.48, 1.91637679}, {1.42, 
            1.69}, {1.41, 1.676}, {1.31, 2.104}, {1.41, 1.67}, {1.44, 
            1.73}, {1.44, 1.67}, {1.41, 1.74}, {1.43, 1.71}, {1.40, 
            1.6469}};   
p4 = 
        ListPlot[yourData, PlotStyle -> {PointSize[0.01], Magenta}, 
          AxesLabel -> {"m", "V2(m)"}, 
          PlotLabel -> "Slope against Total Distance",  
          TextStyle -> {FontSize -> 18}, 
          ImageSize -> {900, 600}];

Defining the Total Distance Function:

Clear[m];   
V2[m_] = 
        Sqrt[(1.2 - m)^2 + (3.8 - 2  m)^2 + (4.2 - 
                  3  m)^2 + (6.3 - 4  m)^2 + (7.2 - 
                  5  m)^2 + (7.3 - 6  m)^2];

Plotting your results and the distance function together:

p5 = 
        Plot[V2[m], {m, 1, 2}, PlotStyle -> {Green}, 
          DisplayFunction -> Identity];
Show[{p4, p5}];

The following animation shows how the value of (Subscript[V, 2])(m) changes as the slope of the line changes

AnimateDistanceFunction[rootData, V2]