Ну если порядок следования в них данных одинаков, т.е. одинаковы индексы для соответствующих значений, то так:

$all = array();
foreach ($patches as $index => $path) {
    $all[] = $path . '/' . $files[$index] . '/' . $exts[$index];
}

В такой ситуации лучше всего изменить сам подход! "Параллельные" массивы - суть зло Лучше сделать объект, в котором хранить данные, относящиеся к чему-то одному. И сделать массив таких объектов.
То есть, делаешь класс, в котором основное - это свойства. Можно и функцию сделать, например конструктор, для данные сразу же при создании записывать.

И потом уже не важно даже, какие будут индексы, цифровые или символьные - ты сможешь пройти по массиву одним циклом. Сможешь удалить ненужные данные (один элемент) всего за одно действие.

Короче говоря - удобнее намного.

$info = array(
   array(
      'path' => '...',
      'file' => '...',
      'ext' => '...'
   ),
   ...
   array(
      'path' => '...',
      'file' => '...',
      'ext' => '...'
   )
);

vagrand - всё равно это параллельные массивы, не важно, что ты их запаковываешь внутрь некоего общего массива!!! Всё равно надо получить целостность данных, чтобы случайно не удалить данные из одного массива, оставив их в другом.
То есть, суть не меняется.

В качестве пример таких параллельных массивов могу привести свою же работу на графическом конкурсе http://phpforum.ru/index.php?showtopic=28500.
Там есть ссылка на текст (архив). И вот там, в файле functions.php есть класс one_point, описывающий одну точку. А в классе graph_info уже используется массив этих точек, представителей класса one_point.
Ну и, естественно, этот массив используется потом при работе скрипта.

Этот пример - как раз то, о чем идет речь в теме.

Экскузи муа, не сразу вспомнил об этом примере, хотя "в голове какая-то мысль крутилась"

$info = array(
   array(
      'path' => '...',
      'file' => '...',
      'ext' => '...'
   ),
   ...
   array(
      'path' => '...',
      'file' => '...',
      'ext' => '...'
   )
);

$patches=array(...);
$filles=array(...);
$exts=array(...);

vagrand - я не пойму - ты прикидываешься, прикалываешься или читать не умеешь? Вроде бы не глупый человек, а "гонишь пургу".

Вот смотри. Возьмём пример из моей же ссылки, из моего же кода и чуть его упростим-дополним.

// класс описывает одну точку
class one_point 
{
  public $x;
  public $y;
	
  function __construct( $x, $y) { $this->x=$x; $this->y=$y; }
}

// где-то тут был на введен массив $ini_info

  $c=count( $int_info );
  $points=array();
  for( $i=0; $i<$c; $i+=2)
    $points[]=new one_point( $ini_info[$i], $ini_info[$i+1] );
}

Краткое описание:
Одномерный массив $ini_info содержит данные в виде пар координат X и Y, которые как раз и преобразуются в массив объектов...
А именно, берём 2 последовательных элемента массива, и передаём их в конструктор класса one_point. При этом создается один экземпляр этого класса (объект), содержащий 2 параметра, $x и $y. Далее берём следующие 2 элемента массива $ini_info и повторяем всю процедуру. На этом шаге создается второй элемент массива объектов, содержащий, опять же, 2 параметра $x и $y, но только уже свои собственные. И так далее, пока не будут исчерпаны все элементы исходного массива.
В результате у нас есть массив объектов $points.

И вот уже на этом этапе получаем то самое преимущество, о котором я говорил. Мы имеем массив объектов. Мы можем удалить любой из элементов массива $points ( unset($points[4], например), при этом будут удалены ОБЕ координаты. Но мы не затронем координаты других точек, т.е. данные в других объектах.

Мы можем добавить новые точки. Старые данные также не будут затронуты. Мы даже можем перетасовать объекты, как и элементы любого другого массива, при этом мы будем работать только с массивом $points. Координаты каждой точки будут оставаться взаимосвязанными. Не будет 2-х "параллельных" массивов "ИКС" и "ИГРЕК", а будет один массив ТОЧКИ.

А что нам мешает усложнить описание, добавить 3-й элемент в класс one_point, например, некоторое описание? Да ничто не мешает!

class one_point 
{
  public $x;
  public $y;
  public $name;	

  function __construct( $x, $y, $name) { $this->x=$x; $this->y=$y; $this->name=$name; }
}

// тогда при создании точки мы можем написать что-то типа 
$points[]=new one_point( 4, 5, 'initial point');

И эта третья часть также будет единой частью неделимого объекта... Всё сказанное ранее о целостности данных будет справедливо и для этого объекта. Что мешает наращивать и усложнять структуру? Ничто Только если здравый смысл, чтоб не перемудрить.

PS. И это даже не ООП, а так, "детский лепет ООП"; простое использование классов как контейнеров для данных. Не знаю насчет скорости, ловить 10е-5 секунды я не собираюсь. Но если мне удобнее работать с объектами, а не с кучей "параллельных" (взаимосвязанных) массивов, то я так и буду работать. И буду это рекомендовать другим.

Да что вы так кипятитесь, если есть 100% уверенность в том, что элементы массива совпадают, то нечего тут городить ООП и прочее, делается как написал vagrand

Удаление в случае с массивом работает по тому же принципу:

unset($array[<индекс нужного элемента>]);

А для создания массива массивов можно написать функцию которая будет создавать массив:

function CreateNeedArray($x, $y) {
   return array('x' => $x, 'y' => $y);
}

И будет тоже самое. Так же не вижу смысла в применении в данном случае ООП.

А я как раз и веду речь о том, что даже думать не надо будет на тему "что элементы массива совпадают" Да и другие "фенечки" автоматически появляются.
Кстати говоря, программисты, "познавшие Си" , вполне могут узнать в показанном мной выше коде Сишный подход. И почему бы не использовать то, что себя зарекомендовало только с лучшей стороны?

Спасибо за ответы, друзья. Мне подходит метод предложеный vagrand-ом.
Применил для переименования группы файлов, в первом массиве старые имена, во втором новые полное соответствие ключей. Не могут же они перепутаться, если записывались в одинаковом порядке?

Задал вопрос, а тут такие холивары начались))) Сразу видно что тут куча php-шных монстров засело))) И у каждый отстаивает методы своей школы.