So, the square brackets can be used to access element inside the array by passing it's index e.g:

const arr = ["first", "second"];
const secondElement = arr[1] // index 1 means seconds element

and also square brackets can be used to access element inside the object by passing it's key e.g:

const obj = { first: 1, second: 2 };
const secondElement = object.second // Normal way to access value in object
const secondElementWithAnotherSyntax = object['second'] // another syntax, same thing

the cool thing about the other syntax shown is that you can pass variable to it, e.g :

const objKey = 'second'
const secondElement = obj[objKey]

Now let's look at your example, i is one element of the array order, which carries arrays itself, so i is also one of the two small arrays, i[0] is the string word in the beginning of the small arrays, so:

i[0] // is either 'shirt' or 'shoes' and since stocks is an object that has those keys, you can access for example the value 50 by saying stocks['shirt'] or as in your case, stock[i[0]] ;)

now your second question: why should it be >= i[1] ? because the order second item , aka i[1] is the number of items required/ordered, so this should always be less that your stock, you can't by 5 shirts from a place that has only 3 in the stock :)

May I suggest to try to use more expressive naming of the variables ?

An object property can be accessed through bracket notation, as in stock[orderedProductName] when using a variable - Property accessors

A concise but imho more readable version can be written using destructuring assignment

const order = [
  ["shirt", 5],
  ["shoes", 2]
];

const stock = {
 shirt: 50,
 height: 172,
 mass: 120,
 shoes: 6,
};

// original version

let inStock = order.every((i) => stock[i[0]] >= i[1]); /// return true


// more verbose version
// check if every item in array order satisfies the condition
// let's cycle over the array calling the element we're working on
// orderItem

inStock = order.every( orderItem => {
  const orderedProductName = orderItem[0];
  const orderedProductQuantity = orderItem[1];
  // to access an object property we can use bracket notation
  const stockProductQuantity = stock[orderedProductName];
  
  // the condition to check: do we have enough products in stock ?
  return stockProductQuantity >= orderedProductQuantity;
});


// a concise variation could make use of destructuring assignment.
// Here, when we take the order item array, we immediately assign
// each of its elements to the appropriate variable
//
// orderItem[0] or first array element -> productName
// orderItem[1] or second array element -> orderedQuantity

inStock = order.every(([productName, orderedQuantity]) => 
  stock[productName] >= orderedQuantity
);

if(inStock) {
  console.log('pack and ship');
}
else {
  console.log('need to restock'); 
}

1. stock is an Object. Why i must write as an array?

You can access properties of objects using brackets [].

Why do we need this?

1. To be able to access properties of objects dynamically, e.g. when you are looping though keys and want to get the values

Object.keys(data).forEach(function(key) {
  console.log('Key : ' + key + ', Value : ' + data[key])
})

2. Sometimes there is no other way to access the value:

const json = {
  "id":"1",
  "some key with spaces": "48593"
};

console.log(json.some key with spaces); // obviously throws error
console.log(json['some key with spaces']); // prints "48593"

2. Why it is i[0] in stock and then i[1] ?

3. Why this code checks the nested Arrays in const order ?

The code goes through the orders, each order is an array so i[0] is the type of the order and i[1] is the quantity. the code checks if there are enough items in stock. To check if there are enough shirts you would do:

console.log(stock["shirts"] >= 5

Thats what the code in your example does, it just passes the key ("shirts") and quantity (5) dynamically.