Where can I see Hook definitions on my localhost?

You can "define" a hook for your own module without ever creating a function for that hook, I know that sounds odd, but here is a practical example from Ubercart. Ubercart as its own function uc_cart_add_item which basically adds an item to the shoppers cart. In this function, you will see this code, which basically lets other modules "hook into" the add process and do something with the node being added.

$result = module_invoke_all('add_to_cart', $nid, $qty, $data);
  if (is_array($result) && !empty($result)) {
    foreach ($result as $row) {
      if ($row['success'] === FALSE) {
        if (isset($row['message']) && !empty($row['message'])) {
          $message = $row['message'];
        }
        else {
          $message = t('Sorry, that item is not available for purchase at this time.');
        }
        if ($row['silent'] === TRUE) {
          if ($check_redirect) {
            if (isset($_GET['destination'])) {
              drupal_goto();
            }
            $redirect = variable_get('uc_add_item_redirect', 'cart');
            if ($redirect != '<none>') {
              $_SESSION['uc_cart_last_url'] = uc_referer_uri();
              return $redirect;
            }
            else {
              return uc_referer_uri();
            }
          }
        }
        else {
          drupal_set_message($message, 'error');
        }
        return;
      }
    }
  }

So, there is no "add_to_cart" function, but if you as a third party developer want to hook into this process, you would build a function like this:

function mymodule_add_to_cart($nid, $qty, $data) {
  // do something with the variables passed in
 // return a value of true or false
}

The ubercart guys do a great job of documentation their hooks

/**
 * Do extra processing when an item is added to the shopping cart.
 *
 * Some modules need to be able to hook into the process of adding items to a
 * cart. For example, an inventory system may need to check stock levels and
 * prevent an out of stock item from being added to a customer's cart. This hook
 * lets developers squeeze right in at the end of the process after the product
 * information is all loaded and the product is about to be added to the cart.
 * In the event that a product should not be added to the cart, you simply have
 * to return a failure message described below. This hook may also be used simply
 * to perform some routine action when products are added to the cart.
 *
 * @param $nid
 *   The node ID of the product
 * @param $qty
 *   The quantity being added
 * @param $data
 *   The data array, including attributes and model number adjustments
 * @return
 *   The function can use this data to whatever purpose to see if the item can
 *   be added to the cart or not. The function should return an array containing
 *   the result array. (This is due to the nature of Drupal's module_invoke_all()
 *   function. You must return an array within an array or other module data will
 *   end up getting ignored.) At this moment, there are only three keys:
 *   - "success": TRUE or FALSE for whether the specified quantity of the item
 *       may be added to the cart or not; defaults to TRUE.
 *   - "message": the fail message to display in the event of a failure; if
 *       omitted, Ubercart will display a default fail message.
 *   - "silent": return TRUE to suppress the display of any messages; useful
 *       when a module simply needs to do some other processing during an add to
 *       cart or fail silently.
 */
function hook_add_to_cart($nid, $qty, $data) {
  if ($qty > 1) {
    $result[] = array(
      'success' => FALSE,
      'message' => t('Sorry, you can only add one of those at a time.'),
    );
  }
  return $result;
}

I hope this helps. The hook system is really cool but can be a little daunting at first, you got stuff firing all over the place!

I'm sot sure how the documentation pages are built; maybe some clever regex finds all core hooks, but I can also imagine that the list is 'editorial'.

Available hooks and hook implementations are not stored in the database. The naming convention of hook implementations is essential: when a module implements a hook, that function is called [modulename]_[hookname]. When Drupal initializes, all .module files of the enabled modules are included, defining all functions inside including the hook implementations. When a hook is invoked, Drupal looks up which modules have defined a function with the appropriate name (the essence of that process is in the module_hook function: http://api.drupal.org/api/function/module_hook/6). For instance, when hook_init is invoked, Drupal will check if node.module defined node_init(), if comment.module defined comment_init(), and so on. If the function is defined, it is executed.

[edit]
By the way, an interesting detail is that a hook registry was added to the development version of Drupal 7 in an attempt to improve performance. When it turned out that this didn't work as expected, a large part was taken out again.