A limitation of my previous response is that it depended on dsolve being able to solve the differential equations symbolically.  Here is a modification that uses dsolve/numeric.  Note that I used the optional parameter 'initialvalues' in the call NonlinearFit, that was necessary to avoid a range that dsolve could not integrate.  This is slower, it takes about 45 seconds.

T := Vector([0., 10.0, 20.0, 31.0, 41.0, 52.0, 63.0, 101.0, 118.0, 146.0, 175.0]):

Z := Vector([NULL
             , 0.26134778186274507e-1
             , 0.5998907077205882e-1
             , 0.9122613357843135e-1
             , .15470589797794115
             , .15113937469362743
             , .17105442156862743
             , .2182091648284313
             , .13516658731617642
             , .10597567371323527
             , 0.8211602236519606e-1
             , 0.7081520343137254e-1
            ]):

L := piecewise(t<=63
               , c*(F*(1-exp(-Delta*t))   + beta*exp(-Delta*t))
               , c*(F*(1-exp(-Delta*tau)) + beta*exp(-Delta*tau))*exp(-Delta*(t-tau))
              ):

GivenParams := {F=0.015,c=4.46,Delta=0.088,beta=0.007,tau=63}:

deqs := {NULL
         , -diff(y(t),t)+2*p1*f*L-p1*y(t)
         , -diff(x(t),t)+2*p2*(1-f)*L-p2*x(t)
         , x(0) = 0, y(0) = 0
        }:

dsol := dsolve(eval(deqs, GivenParams), {x,y}(t), 'numeric', 'parameters'=[p1,p2,f]):

z := (x(t)+y(t))/2/F/c:
znum := eval(z, GivenParams):

zcompute := proc(t,p1,p2,f)
    dsol('parameters' = [p1,p2,f]);
    eval(znum, dsol(t));
end proc:

FoundParams := Statistics:-NonlinearFit(zcompute, T, Z
                                        , output=parametervalues
                                        , initialvalues = <.01, .001, 0.1>
                                       );

dsol('parameters' = convert(FoundParams,'list'));
plt_fit := plots[odeplot](dsol, [t, znum], 0..175):
plt_data := plot(zip(`[]`,T,Z), style=point):

plots:-display([plt_data,plt_fit]);

The awful results from this particular posted use of the GlobalOptimization toolbox are due to the fact that, as the problem was originally set up, the solver would only be able to do a relatively small number of global search evaluations before it timed out. The reason for this is because dsolve(...,numeric) was being called an enormous number of times. The act of setting up the dsolve/numeric solver was itself being done inside the objective function, at each evaluation of the objective.

Joe's responses show how the dsolve calls may be brought outside the evaluation routines, to be done just once as a set-up step.

Once the objective is made fast enough, and can run enough times to to the global optimizer a chance to do enough evaluations, it can find decent results.

I consider Joe's responses to be excellent.  I also feel that these techniques could be better documented in the product. A worksheet could illustrate the ideas nicely. And that might be usefully referenced from the help-pages of both dsolve/numeric, Optimization, and GlobalOptimization. One could construct a problem for which the numeric DE solving was involved within a root-finding problem, and thus the parametrized numeric DE solver needed to be called from fsolve.

acer