I don't think you missed a particular function. Though it can be done faster. For one, you don't need to scan/touch the 'core', I can just start looking at the edge, and once I see non-padding I don't have to scan further. By cyclically Transposing the data I can check if that digit (array, matrix, hypermatrix) is only the padding stuff and if so, remove it. It can be done also without transposing but it is trickier...

$HistoryLength = 1;
ClearAll[ArrayCrop, DeleteStart, DeleteM, TransposeAndDelete]
DeleteStart[m_, pad_] := Module[{len},
  len = LengthWhile[m, MatchQ[Flatten[{#}], {pad ..}] &];
  Drop[m, len]
  ]
DeleteM[m_, pad_] := Reverse[DeleteStart[Reverse[DeleteStart[m, pad]], pad]]
TransposeAndDelete[m_, pad_] := DeleteM[Transpose[m, RotateLeft[Range[Depth[m] - 1]]], pad]
ArrayCrop2[m_, pad_] := Nest[TransposeAndDelete[#, pad] &, m, Depth[m] - 1]
ArrayCrop2[m_] := ArrayCrop2[m, 0]

1D:

core = {x, y, z};
l = ArrayPad[core, {2, 3}]
ArrayCrop[l] === ArrayCrop2[l] === core

2D:

core = {{0, x, y}, {x, x, x}, {0, x, 0}};
m = ArrayPad[core, {{1, 2}, {3, 4}}];
ArrayCrop[m] === ArrayCrop2[m] === core

5D:

core=RandomInteger[9,{10,20,30,40,50}];
pad=ArrayPad[core,{{1,1},{2,4},{5,6},{7,8},{9,10}}];
AbsoluteTiming[ac=ArrayCrop[pad];]
AbsoluteTiming[ac2=ArrayCrop2[pad];]
core===ac===ac2

5x speed up compared to your solution for big solutions, there may be room for more improvement by passing things by reference...

Ok, without transposing I get a ~12x speed up:

ClearAll[ExtractND, LengthWhileN, ArrayCrop3]
ExtractND[m_, n_, i_] := Module[{spec},
  spec = ConstantArray[All, n];
  spec[[-1]] = i;
  Flatten[{Extract[m, spec]}]
  ]
LengthWhileN[m_, n_, pad_] := Module[{dims, dim, front, back},
  dims = Dimensions[m];
  dim = dims[[n]];
  front = LengthWhile[Range[dim], MatchQ[ExtractND[m, n, #], {pad ..}] &];
  back = LengthWhile[Range[dim], MatchQ[ExtractND[m, n, -#], {pad ..}] &];
  {front, back}
  ]
ArrayCrop3[m_] := ArrayCrop3[m, 0]
ArrayCrop3[m_, pad_] := Module[{d, padding},
  d = Depth[m] - 1;
  padding = LengthWhileN[m, #, pad] & /@ Range[d];
  padding++;
  padding[[All, 2]] *= -1;
  Extract[m, Span @@@ padding]
  ]

Which is roughly 12-13x faster for the large example... This is probably at the limits of speed you can get because in the end you have to check something. It leaves the entire core (except 1 'layer') untouched, does not transpose. The code could be changed to crop at each level before going to the next level, this might speed things up a bit because the matrix would get smaller and smaller (if there is something to crop of course).