Add ErrNotPermitted error for permission denied in feature probes

[javiercardona-work]

Add ErrNotPermitted to distinguish permission denied (EPERM) from feature not supported (EINVAL) in feature probes.

Problem

Previously, feature probes treated EPERM and EINVAL identically, returning ErrNotSupported for both. This was imprecise:

• EINVAL: kernel doesn't recognize the request (feature not supported)
• EPERM: kernel recognized the request but denied permission (feature exists)

Solution

Feature probes now return:

• nil: feature is supported and accessible
• ErrNotSupported: kernel doesn't have the feature
• ErrNotPermitted: feature exists but permission denied

ErrNotPermitted wraps the original EPERM error so callers can unwrap if needed.

Usage

err := features.HaveProgramType(ebpf.XDP)                                                                                                                                                                                                  
switch {                                                                                                                                                                                                                                   
case err == nil:                                                                                                                                                                                                                           
    // feature works                                                                                                                                                                                                                       
case errors.Is(err, ebpf.ErrNotSupported):                                                                                                                                                                                                 
    // kernel doesn't have it                                                                                                                                                                                                              
case errors.Is(err, ebpf.ErrNotPermitted):                                                                                                                                                                                                 
    // permission denied (but feature exists)                                                                                                                                                                                              
}                                                                                                                                                                                                                                          

Breaking Change

Code checking only for ErrNotSupported will no longer catch permission errors. To maintain previous behavior:

  // Before:                                                                                                                                                                                                                                 
  if errors.Is(err, ebpf.ErrNotSupported) { ... }                                                                                                                                                                                            
                                                                                                                                                                                                                                             
  // After:                                                                                                                                                                                                                                  
  if errors.Is(err, ebpf.ErrNotSupported) || errors.Is(err, ebpf.ErrNotPermitted) { ... }                                                                                                                                                    
                                                                                                                                                                                                                                             
  // Or simply:                                                                                                                                                                                                                              
  if err != nil { ... }